@valerypopoff/rivet2-evaluations 2.3.0

package/dist/cjs/bundle.cjs

@@ -0,0 +1,3160 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EvaluationGraphExecutionError: () => EvaluationGraphExecutionError,
+  InMemoryEvaluationRunStore: () => InMemoryEvaluationRunStore,
+  LEGACY_EVALUATOR_INPUT_IDS: () => LEGACY_EVALUATOR_INPUT_IDS,
+  areEvaluationDataTypesCompatible: () => areEvaluationDataTypesCompatible,
+  assertEvaluationDatasetSnapshot: () => assertEvaluationDatasetSnapshot,
+  assertEvaluationDatasetValuesMatchDeclaredTypes: () => assertEvaluationDatasetValuesMatchDeclaredTypes,
+  assertPortableJson: () => assertPortableJson,
+  canonicalStringify: () => canonicalStringify,
+  canonicalizePortableJson: () => canonicalizePortableJson,
+  clonePortableJson: () => clonePortableJson,
+  createEmptyEvaluationProjectData: () => createEmptyEvaluationProjectData,
+  createEmptyMetrics: () => createEmptyMetrics,
+  createEvaluationBaselineSnapshot: () => createEvaluationBaselineSnapshot,
+  deserializeEvaluationDatasetJson: () => deserializeEvaluationDatasetJson,
+  deserializeEvaluationProjectData: () => deserializeEvaluationProjectData,
+  deserializeEvaluationProjectDataFromString: () => deserializeEvaluationProjectDataFromString,
+  deserializeEvaluationSuiteBundleJson: () => deserializeEvaluationSuiteBundleJson,
+  evaluateAssertion: () => evaluateAssertion,
+  evaluateThresholdResults: () => evaluateThresholdResults,
+  finalizeEvaluationRecordingRetention: () => finalizeEvaluationRecordingRetention,
+  fingerprint: () => fingerprint,
+  fingerprintEvaluationDataset: () => fingerprintEvaluationDataset,
+  getEvaluationSuiteMode: () => getEvaluationSuiteMode,
+  getEvaluationTopLevelOutputId: () => getEvaluationTopLevelOutputId,
+  hasAuthoritativeEvaluationCriteria: () => hasAuthoritativeEvaluationCriteria,
+  isEvaluationOutputPathSyntaxValid: () => isEvaluationOutputPathSyntaxValid,
+  isEvaluationValueCompatibleWithDataType: () => isEvaluationValueCompatibleWithDataType,
+  isPortableEvaluationDataType: () => isPortableEvaluationDataType,
+  localizeEvaluationDataset: () => localizeEvaluationDataset,
+  normalizeEvaluationAggregate: () => normalizeEvaluationAggregate,
+  normalizeEvaluationBaselineSnapshot: () => normalizeEvaluationBaselineSnapshot,
+  normalizeEvaluationRun: () => normalizeEvaluationRun,
+  normalizeEvaluationTrial: () => normalizeEvaluationTrial,
+  portableEvaluationDataTypes: () => portableEvaluationDataTypes,
+  runEvaluationCases: () => runEvaluationCases,
+  runEvaluationSuite: () => runEvaluationSuite,
+  runEvaluationWorkPool: () => runEvaluationWorkPool,
+  serializeEvaluationDatasetJson: () => serializeEvaluationDatasetJson,
+  serializeEvaluationProjectData: () => serializeEvaluationProjectData,
+  serializeEvaluationProjectDataToString: () => serializeEvaluationProjectDataToString,
+  serializeEvaluationSuiteBundleJson: () => serializeEvaluationSuiteBundleJson,
+  shouldReplaceEvaluationRun: () => shouldReplaceEvaluationRun,
+  summarizeEvaluationRun: () => summarizeEvaluationRun,
+  usesLegacyEvaluatorInputEnvelope: () => usesLegacyEvaluatorInputEnvelope,
+  validateEvaluationAssertionConfiguration: () => validateEvaluationAssertionConfiguration,
+  validateEvaluationAssertionExpectedValue: () => validateEvaluationAssertionExpectedValue,
+  validateEvaluationDataset: () => validateEvaluationDataset,
+  validateEvaluationDatasetForTransfer: () => validateEvaluationDatasetForTransfer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var EvaluationGraphExecutionError = class extends Error {
+  metrics;
+  recording;
+  providerAttempts;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "EvaluationGraphExecutionError";
+    this.metrics = details.metrics;
+    this.recording = details.recording;
+    this.providerAttempts = details.providerAttempts;
+  }
+};
+
+// src/canonical.ts
+function assertPortableJson(value, path = "$", stack = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${path} must not contain a non-finite number.`);
+    return;
+  }
+  if (typeof value !== "object") throw new Error(`${path} must be portable JSON.`);
+  if (stack.has(value)) throw new Error(`${path} must not contain a cycle.`);
+  if (Array.isArray(value)) {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new Error(`${path} must not contain symbol-keyed array properties.`);
+    }
+    stack.add(value);
+    try {
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, index);
+        if (!descriptor) throw new Error(`${path}[${index}] must not be a sparse array entry.`);
+        if (!descriptor.enumerable || descriptor.get || descriptor.set) {
+          throw new Error(`${path}[${index}] must be an enumerable data property.`);
+        }
+        assertPortableJson(descriptor.value, `${path}[${index}]`, stack);
+      }
+      if (Object.getOwnPropertyNames(value).length !== value.length + 1) {
+        throw new Error(`${path} must not contain hidden or extra array properties.`);
+      }
+    } finally {
+      stack.delete(value);
+    }
+    return;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new Error(`${path} must be a plain object.`);
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new Error(`${path} must not contain symbol-keyed object properties.`);
+  }
+  const ownPropertyNames = Object.getOwnPropertyNames(value);
+  const keys = Object.keys(value);
+  if (ownPropertyNames.length !== keys.length) {
+    throw new Error(`${path} must not contain non-enumerable object properties.`);
+  }
+  stack.add(value);
+  try {
+    for (const key of keys) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || descriptor.get || descriptor.set) {
+        throw new Error(`${path}.${key} must be an enumerable data property.`);
+      }
+      assertPortableJson(descriptor.value, `${path}.${key}`, stack);
+    }
+  } finally {
+    stack.delete(value);
+  }
+}
+function canonicalizePortableJson(value) {
+  assertPortableJson(value);
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(canonicalizePortableJson);
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, canonicalizePortableJson(value[key])])
+  );
+}
+function clonePortableJson(value) {
+  assertPortableJson(value);
+  return structuredClone(value);
+}
+function canonicalStringify(value) {
+  return JSON.stringify(canonicalizePortableJson(value));
+}
+function fingerprint(value) {
+  const source = canonicalStringify(value);
+  let hash = 0xcbf29ce484222325n;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= BigInt(source.charCodeAt(index));
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
+}
+function fingerprintEvaluationDataset(value) {
+  return fingerprint({ datasetId: value.id, fields: value.fields, cases: value.cases });
+}
+function assertEvaluationDatasetSnapshot(snapshot) {
+  if (snapshot.dataset.projectId !== void 0 && snapshot.dataset.projectId !== snapshot.projectId) {
+    throw new Error("An evaluation dataset snapshot must belong to its project.");
+  }
+  if (fingerprintEvaluationDataset(snapshot.dataset) !== snapshot.fingerprint) {
+    throw new Error("An evaluation dataset snapshot fingerprint must match its dataset ID, fields, and cases.");
+  }
+}
+
+// src/assertions.ts
+function readQuotedPathKey(source, start) {
+  const quote = source[start];
+  if (quote !== '"' && quote !== "'") return void 0;
+  let cursor = start + 1;
+  let key = "";
+  while (cursor < source.length) {
+    const character = source[cursor++];
+    if (character === quote) return { key, cursor };
+    if (character !== "\\") {
+      key += character;
+      continue;
+    }
+    const escaped = source[cursor++];
+    if (escaped === void 0) return void 0;
+    if (escaped === "u") {
+      const hex = source.slice(cursor, cursor + 4);
+      if (!/^[0-9a-fA-F]{4}$/.test(hex)) return void 0;
+      key += String.fromCharCode(Number.parseInt(hex, 16));
+      cursor += 4;
+      continue;
+    }
+    const escapes = {
+      '"': '"',
+      "'": "'",
+      "\\": "\\",
+      "/": "/",
+      b: "\b",
+      f: "\f",
+      n: "\n",
+      r: "\r",
+      t: "	"
+    };
+    if (!(escaped in escapes)) return void 0;
+    key += escapes[escaped];
+  }
+  return void 0;
+}
+function parseEvaluationOutputPath(path) {
+  const source = path.trim();
+  if (source === "$") return [];
+  if (!source.startsWith("$") || source.length === 1) return void 0;
+  let cursor = 1;
+  const segments = [];
+  while (cursor < source.length) {
+    if (source[cursor] === ".") {
+      cursor += 1;
+      while (/\s/u.test(source[cursor] ?? "")) cursor += 1;
+      const identifier = /^[A-Za-z_$][\w$]*/u.exec(source.slice(cursor));
+      if (!identifier) return void 0;
+      segments.push({ kind: "property", key: identifier[0] });
+      cursor += identifier[0].length;
+    } else if (source[cursor] === "[") {
+      cursor += 1;
+      while (/\s/u.test(source[cursor] ?? "")) cursor += 1;
+      const quoted = readQuotedPathKey(source, cursor);
+      if (quoted) {
+        segments.push({ kind: "property", key: quoted.key });
+        cursor = quoted.cursor;
+      } else {
+        const index = /^\d+/u.exec(source.slice(cursor));
+        if (!index) return void 0;
+        segments.push({ kind: "index", index: Number(index[0]) });
+        cursor += index[0].length;
+      }
+      while (/\s/u.test(source[cursor] ?? "")) cursor += 1;
+      if (source[cursor] !== "]") return void 0;
+      cursor += 1;
+    } else {
+      return void 0;
+    }
+  }
+  return segments;
+}
+function isEvaluationOutputPathSyntaxValid(path) {
+  return parseEvaluationOutputPath(path) !== void 0;
+}
+function getEvaluationTopLevelOutputId(path) {
+  var _a;
+  const first = (_a = parseEvaluationOutputPath(path)) == null ? void 0 : _a[0];
+  return (first == null ? void 0 : first.kind) === "property" ? first.key : void 0;
+}
+function getPath(value, path) {
+  const segments = parseEvaluationOutputPath(path);
+  if (!segments) return void 0;
+  let current = value;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      if (segment.kind !== "index") return void 0;
+      const index = segment.index;
+      if (!Number.isInteger(index) || index < 0 || index >= current.length) return void 0;
+      current = current[index];
+      continue;
+    }
+    if (segment.kind !== "property") return void 0;
+    if (current === null || typeof current !== "object" || !Object.hasOwn(current, segment.key)) return void 0;
+    current = current[segment.key];
+  }
+  return current;
+}
+function expectedValue(assertion, testCase) {
+  if (assertion.expected.kind === "literal") return assertion.expected.value;
+  const value = testCase.values[assertion.expected.fieldId];
+  if (value === void 0) throw new Error(`Expected dataset field "${assertion.expected.fieldId}" is missing.`);
+  return value;
+}
+function typeMatches(actual, expected) {
+  if (typeof expected !== "string") return false;
+  if (actual === void 0) return false;
+  if (expected === "array") return Array.isArray(actual);
+  if (expected === "null") return actual === null;
+  if (expected === "object") return actual !== null && typeof actual === "object" && !Array.isArray(actual);
+  return typeof actual === expected;
+}
+function expectedTextList(assertion, expected) {
+  if (!Array.isArray(expected) || expected.length === 0 || expected.some((value) => typeof value !== "string")) {
+    throw new Error(`Quality check "${assertion.name}" requires a non-empty array of expected text values.`);
+  }
+  return expected;
+}
+function assertionConfigurationError(assertion, message) {
+  throw new Error(`Quality check "${assertion.name}" ${message}`);
+}
+var ASSERTION_TYPE_NAMES = /* @__PURE__ */ new Set(["array", "boolean", "null", "number", "object", "string"]);
+function expectedTypeName(assertion, expected) {
+  if (typeof expected !== "string" || !ASSERTION_TYPE_NAMES.has(expected)) {
+    assertionConfigurationError(
+      assertion,
+      "requires one of these expected type names: array, boolean, null, number, object, or string."
+    );
+  }
+  return expected;
+}
+function expectedString(assertion, expected, description) {
+  if (typeof expected !== "string") {
+    assertionConfigurationError(assertion, `requires ${description} to be a string.`);
+  }
+  return expected;
+}
+function expectedFiniteNumber(assertion, expected, description) {
+  if (typeof expected !== "number" || !Number.isFinite(expected)) {
+    assertionConfigurationError(assertion, `requires ${description} to be a finite number.`);
+  }
+  return expected;
+}
+function expectedNumberRange(assertion, expected) {
+  if (!Array.isArray(expected) || expected.length !== 2 || typeof expected[0] !== "number" || !Number.isFinite(expected[0]) || typeof expected[1] !== "number" || !Number.isFinite(expected[1])) {
+    assertionConfigurationError(assertion, "requires an expected range containing exactly two finite numbers.");
+  }
+  if (expected[0] > expected[1]) {
+    assertionConfigurationError(assertion, "requires its expected range minimum to be no greater than its maximum.");
+  }
+  return expected;
+}
+function expectedSet(assertion, expected) {
+  if (!Array.isArray(expected)) assertionConfigurationError(assertion, "requires the expected set to be an array.");
+  return expected;
+}
+function operatorDescription(operator) {
+  switch (operator) {
+    case "equals":
+      return "equals";
+    case "not-equals":
+      return "does not equal";
+    case "contains":
+      return "contains the expected text";
+    case "matches-regex":
+      return "matches the regular expression";
+    case "type-is":
+      return "has the expected type";
+    case "json-schema":
+      return "matches the JSON Schema";
+    case "number-at-least":
+      return "is at least the expected value";
+    case "number-at-most":
+      return "is at most the expected value";
+    case "number-between":
+      return "is inside the expected range";
+    case "array-includes":
+      return "includes the expected value";
+    case "set-overlaps":
+      return "overlaps the expected set";
+    case "contains-any":
+      return "contains any expected text";
+    case "contains-all":
+      return "contains every expected text";
+  }
+}
+function validateEvaluationAssertionExpectedValue(assertion, expected) {
+  assertPortableJson(expected, `quality check ${assertion.name} expected value`);
+  switch (assertion.operator) {
+    case "equals":
+    case "not-equals":
+    case "array-includes":
+      return;
+    case "contains":
+      expectedString(assertion, expected, "its expected text");
+      return;
+    case "matches-regex": {
+      const pattern = expectedString(assertion, expected, "its expected regular expression");
+      try {
+        new RegExp(pattern);
+      } catch {
+        assertionConfigurationError(assertion, "contains an invalid expected regular expression.");
+      }
+      return;
+    }
+    case "type-is":
+      expectedTypeName(assertion, expected);
+      return;
+    case "json-schema":
+      assertSupportedJsonSchema(assertion, expected);
+      return;
+    case "number-at-least":
+      expectedFiniteNumber(assertion, expected, "its expected minimum");
+      return;
+    case "number-at-most":
+      expectedFiniteNumber(assertion, expected, "its expected maximum");
+      return;
+    case "number-between":
+      expectedNumberRange(assertion, expected);
+      return;
+    case "set-overlaps":
+      expectedSet(assertion, expected);
+      return;
+    case "contains-any":
+    case "contains-all":
+      expectedTextList(assertion, expected);
+      return;
+  }
+}
+function validateEvaluationAssertionConfiguration(assertion, expected) {
+  if (!isEvaluationOutputPathSyntaxValid(assertion.outputPath)) {
+    assertionConfigurationError(assertion, `uses invalid output path "${assertion.outputPath}".`);
+  }
+  validateEvaluationAssertionExpectedValue(assertion, expected);
+}
+var SUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "type",
+  "enum",
+  "const",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "minimum",
+  "maximum",
+  "minItems",
+  "maxItems",
+  "items",
+  "required",
+  "properties",
+  "additionalProperties"
+]);
+var SUPPORTED_SCHEMA_TYPES = /* @__PURE__ */ new Set(["array", "boolean", "integer", "null", "number", "object", "string"]);
+function schemaRecord(assertion, schema, path) {
+  if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
+    assertionConfigurationError(assertion, `requires the JSON Schema at ${path} to be an object.`);
+  }
+  return schema;
+}
+function assertNonNegativeInteger(assertion, value, path) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    assertionConfigurationError(assertion, `requires ${path} to be a non-negative safe integer.`);
+  }
+}
+function assertSupportedJsonSchema(assertion, schema, path = "$") {
+  const objectSchema = schemaRecord(assertion, schema, path);
+  for (const keyword of Object.keys(objectSchema)) {
+    if (!SUPPORTED_SCHEMA_KEYWORDS.has(keyword)) {
+      assertionConfigurationError(assertion, `uses unsupported JSON Schema keyword "${keyword}" at ${path}.`);
+    }
+  }
+  if (objectSchema.type !== void 0) {
+    if (typeof objectSchema.type !== "string" || !SUPPORTED_SCHEMA_TYPES.has(objectSchema.type)) {
+      assertionConfigurationError(
+        assertion,
+        `requires ${path}.type to be one of: array, boolean, integer, null, number, object, or string.`
+      );
+    }
+  }
+  if (objectSchema.enum !== void 0 && (!Array.isArray(objectSchema.enum) || objectSchema.enum.length === 0)) {
+    assertionConfigurationError(assertion, `requires ${path}.enum to be a non-empty array.`);
+  }
+  for (const keyword of ["minLength", "maxLength", "minItems", "maxItems"]) {
+    if (objectSchema[keyword] !== void 0)
+      assertNonNegativeInteger(assertion, objectSchema[keyword], `${path}.${keyword}`);
+  }
+  if (typeof objectSchema.minLength === "number" && typeof objectSchema.maxLength === "number" && objectSchema.minLength > objectSchema.maxLength) {
+    assertionConfigurationError(assertion, `requires ${path}.minLength to be no greater than ${path}.maxLength.`);
+  }
+  if (typeof objectSchema.minItems === "number" && typeof objectSchema.maxItems === "number" && objectSchema.minItems > objectSchema.maxItems) {
+    assertionConfigurationError(assertion, `requires ${path}.minItems to be no greater than ${path}.maxItems.`);
+  }
+  for (const keyword of ["minimum", "maximum"]) {
+    const value = objectSchema[keyword];
+    if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value))) {
+      assertionConfigurationError(assertion, `requires ${path}.${keyword} to be a finite number.`);
+    }
+  }
+  if (typeof objectSchema.minimum === "number" && typeof objectSchema.maximum === "number" && objectSchema.minimum > objectSchema.maximum) {
+    assertionConfigurationError(assertion, `requires ${path}.minimum to be no greater than ${path}.maximum.`);
+  }
+  if (objectSchema.pattern !== void 0) {
+    if (typeof objectSchema.pattern !== "string") {
+      assertionConfigurationError(assertion, `requires ${path}.pattern to be a string.`);
+    }
+    try {
+      new RegExp(objectSchema.pattern);
+    } catch {
+      assertionConfigurationError(assertion, `contains an invalid regular expression at ${path}.pattern.`);
+    }
+  }
+  if (objectSchema.required !== void 0) {
+    if (!Array.isArray(objectSchema.required) || objectSchema.required.some((key) => typeof key !== "string" || key.length === 0) || new Set(objectSchema.required).size !== objectSchema.required.length) {
+      assertionConfigurationError(assertion, `requires ${path}.required to contain unique, non-empty strings.`);
+    }
+  }
+  if (objectSchema.additionalProperties !== void 0 && typeof objectSchema.additionalProperties !== "boolean") {
+    assertionConfigurationError(assertion, `supports only a boolean ${path}.additionalProperties value.`);
+  }
+  if (objectSchema.items !== void 0) {
+    assertSupportedJsonSchema(assertion, objectSchema.items, `${path}.items`);
+  }
+  if (objectSchema.properties !== void 0) {
+    const properties = schemaRecord(assertion, objectSchema.properties, `${path}.properties`);
+    for (const [key, childSchema] of Object.entries(properties)) {
+      assertSupportedJsonSchema(assertion, childSchema, `${path}.properties[${JSON.stringify(key)}]`);
+    }
+  }
+}
+function schemaTypeMatches(actual, expected) {
+  if (expected === "integer") return typeof actual === "number" && Number.isInteger(actual);
+  return typeMatches(actual, expected);
+}
+function matchesSchema(actual, schema) {
+  if (actual === void 0) return false;
+  const objectSchema = schema;
+  const declaredType = objectSchema.type;
+  if (typeof declaredType === "string" && !schemaTypeMatches(actual, declaredType)) return false;
+  if (Array.isArray(objectSchema.enum) && !objectSchema.enum.some((candidate) => canonicalStringify(candidate) === canonicalStringify(actual ?? null)))
+    return false;
+  if (Object.hasOwn(objectSchema, "const") && canonicalStringify(objectSchema.const) !== canonicalStringify(actual ?? null))
+    return false;
+  if (typeof actual === "string") {
+    if (typeof objectSchema.minLength === "number" && actual.length < objectSchema.minLength) return false;
+    if (typeof objectSchema.maxLength === "number" && actual.length > objectSchema.maxLength) return false;
+    if (typeof objectSchema.pattern === "string") {
+      if (!new RegExp(objectSchema.pattern).test(actual)) return false;
+    }
+  }
+  if (typeof actual === "number") {
+    if (typeof objectSchema.minimum === "number" && actual < objectSchema.minimum) return false;
+    if (typeof objectSchema.maximum === "number" && actual > objectSchema.maximum) return false;
+  }
+  if (Array.isArray(actual)) {
+    if (typeof objectSchema.minItems === "number" && actual.length < objectSchema.minItems) return false;
+    if (typeof objectSchema.maxItems === "number" && actual.length > objectSchema.maxItems) return false;
+    if (objectSchema.items !== void 0 && !actual.every((item) => matchesSchema(item, objectSchema.items)))
+      return false;
+  }
+  if (actual !== null && typeof actual === "object" && !Array.isArray(actual)) {
+    const record = actual;
+    if (Array.isArray(objectSchema.required) && !objectSchema.required.every((key) => typeof key === "string" && Object.hasOwn(record, key)))
+      return false;
+    const properties = objectSchema.properties;
+    if (properties !== void 0) {
+      const propertySchemas = properties;
+      for (const [key, childSchema] of Object.entries(propertySchemas)) {
+        if (Object.hasOwn(record, key) && !matchesSchema(record[key], childSchema)) return false;
+      }
+    }
+    if (objectSchema.additionalProperties === false) {
+      const propertySchemas = properties ?? {};
+      if (Object.keys(record).some((key) => !Object.hasOwn(propertySchemas, key))) return false;
+    }
+  }
+  return true;
+}
+function evaluateAssertion(assertion, outputs, testCase) {
+  const outputRoot = outputs;
+  const actual = getPath(outputRoot, assertion.outputPath);
+  const actualFound = actual !== void 0;
+  const expected = expectedValue(assertion, testCase);
+  validateEvaluationAssertionConfiguration(assertion, expected);
+  let passed = false;
+  switch (assertion.operator) {
+    case "equals":
+      passed = actual !== void 0 && canonicalStringify(actual) === canonicalStringify(expected);
+      break;
+    case "not-equals":
+      passed = actual !== void 0 && canonicalStringify(actual) !== canonicalStringify(expected);
+      break;
+    case "contains":
+      {
+        const expectedText = expected;
+        passed = typeof actual === "string" && actual.includes(expectedText);
+      }
+      break;
+    case "matches-regex":
+      {
+        const pattern = new RegExp(expected);
+        passed = typeof actual === "string" && pattern.test(actual);
+      }
+      break;
+    case "type-is":
+      passed = typeMatches(actual, expected);
+      break;
+    case "json-schema":
+      passed = matchesSchema(actual, expected);
+      break;
+    case "number-at-least":
+      {
+        const minimum = expected;
+        passed = typeof actual === "number" && actual >= minimum;
+      }
+      break;
+    case "number-at-most":
+      {
+        const maximum = expected;
+        passed = typeof actual === "number" && actual <= maximum;
+      }
+      break;
+    case "number-between":
+      {
+        const [minimum, maximum] = expected;
+        passed = typeof actual === "number" && actual >= minimum && actual <= maximum;
+      }
+      break;
+    case "array-includes":
+      passed = Array.isArray(actual) && actual.some((item) => canonicalStringify(item) === canonicalStringify(expected));
+      break;
+    case "set-overlaps":
+      {
+        const candidates = expected;
+        passed = Array.isArray(actual) && candidates.some(
+          (candidate) => actual.some((item) => canonicalStringify(item) === canonicalStringify(candidate))
+        );
+      }
+      break;
+    case "contains-any":
+      {
+        const expectedTexts = expected;
+        passed = typeof actual === "string" && expectedTexts.some((candidate) => actual.includes(candidate));
+      }
+      break;
+    case "contains-all":
+      {
+        const expectedTexts = expected;
+        passed = typeof actual === "string" && expectedTexts.every((candidate) => actual.includes(candidate));
+      }
+      break;
+  }
+  const requirement = operatorDescription(assertion.operator);
+  return {
+    id: assertion.id,
+    kind: "assertion",
+    name: assertion.name,
+    required: assertion.required !== false,
+    status: passed ? "passed" : "failed",
+    message: passed ? `Target output ${requirement}.` : actualFound ? `Target output does not satisfy the requirement: ${requirement}.` : `Target output path "${assertion.outputPath}" does not exist.`,
+    evidence: {
+      actual: actual ?? null,
+      actualFound,
+      expected,
+      outputPath: assertion.outputPath,
+      operator: assertion.operator,
+      expectedSource: assertion.expected.kind,
+      ...assertion.expected.kind === "dataset-field" ? { expectedFieldId: assertion.expected.fieldId } : {}
+    }
+  };
+}
+
+// src/normalization.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isQualityStatus(value) {
+  return ["passed", "failed", "scored", "not-evaluated", "unable-to-evaluate"].includes(String(value));
+}
+function isEvaluationMode(value) {
+  return value === "pass-fail" || value === "scoring";
+}
+function isQualityStatusForMode(status, evaluationMode) {
+  return evaluationMode === "scoring" ? status !== "passed" && status !== "failed" : status !== "scored";
+}
+function isExecutionStatus(value) {
+  return ["completed", "error", "canceled"].includes(String(value));
+}
+function isRunExecutionStatus(value) {
+  return ["queued", "running", "completed", "canceled", "error"].includes(String(value));
+}
+function isTerminalRunExecutionStatus(status) {
+  return status === "completed" || status === "canceled" || status === "error";
+}
+function shouldReplaceEvaluationRun(existing, incoming) {
+  if (!existing) return true;
+  const existingRevision = existing.revision ?? 0;
+  const incomingRevision = incoming.revision ?? 0;
+  if (incomingRevision !== existingRevision) return incomingRevision > existingRevision;
+  return !isTerminalRunExecutionStatus(existing.executionStatus) || isTerminalRunExecutionStatus(incoming.executionStatus);
+}
+function isPurpose(value) {
+  return value === "evaluation" || value === "execution-benchmark";
+}
+function isAccountingStatus(value) {
+  return value === "complete" || value === "partial";
+}
+function isNormalizedScore(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+function reasonForQualityStatus(status, executionStatus) {
+  if (executionStatus === "canceled") return { code: "canceled", message: "The execution was canceled." };
+  if (executionStatus === "error" && status === "failed") {
+    return { code: "target-error", message: "The target graph failed before it could produce a valid result." };
+  }
+  switch (status) {
+    case "passed":
+      return { code: "checks-passed", message: "All required quality criteria passed." };
+    case "failed":
+      return { code: "checks-failed", message: "One or more required quality criteria failed." };
+    case "scored":
+      return { code: "scores-complete", message: "Every requested trial produced a score." };
+    case "not-evaluated":
+      return { code: "no-trial-quality-checks", message: "No per-trial quality check evaluated this result." };
+    case "unable-to-evaluate":
+      return { code: "required-check-error", message: "A required quality criterion could not be evaluated." };
+  }
+}
+function reasonForQualityStatusInMode(status, evaluationMode, executionStatus) {
+  if (evaluationMode === "scoring" && status === "unable-to-evaluate") {
+    return { code: "scores-incomplete", message: "One or more requested trials did not produce a usable score." };
+  }
+  return reasonForQualityStatus(status, executionStatus);
+}
+function isTargetExecutionError(value, observations) {
+  if (typeof value.error === "string" && value.error.length > 0) return true;
+  return observations.some(
+    (observation) => isRecord(observation) && observation.id === "target-error" && observation.kind === "assertion" && observation.status === "error"
+  );
+}
+function legacyQualityFromObservations(observations, targetExecutionError) {
+  if (targetExecutionError) return "failed";
+  const required = observations.filter(
+    (observation) => isRecord(observation) && observation.required !== false
+  );
+  if (required.some((observation) => observation.status === "failed")) return "failed";
+  if (required.some((observation) => observation.status === "error")) return "unable-to-evaluate";
+  if (required.some((observation) => observation.status === "passed")) return "passed";
+  return "not-evaluated";
+}
+function scoringQualityFromObservations(observations) {
+  const evaluatorObservations = observations.filter(
+    (observation) => isRecord(observation) && observation.kind === "graph"
+  );
+  const hasCompleteScore = evaluatorObservations.length > 0 && evaluatorObservations.every(
+    (observation) => observation.status === "scored" && typeof observation.score === "number" && Number.isFinite(observation.score) && observation.score >= 0 && observation.score <= 1
+  );
+  return hasCompleteScore ? "scored" : "unable-to-evaluate";
+}
+function isQualityReasonCompatible(reason, status, purpose, executionStatus) {
+  if (purpose === "execution-benchmark") {
+    return executionStatus === "canceled" ? reason.code === "canceled" : reason.code === "benchmark";
+  }
+  if (executionStatus === "queued" || executionStatus === "running") return reason.code === "in-progress";
+  if (executionStatus === "canceled") return reason.code === "canceled";
+  switch (status) {
+    case "passed":
+      return reason.code === "checks-passed" || reason.code === "thresholds-passed";
+    case "failed":
+      return reason.code === "checks-failed" || reason.code === "thresholds-failed" || reason.code === "target-error";
+    case "scored":
+      return reason.code === "scores-complete";
+    case "not-evaluated":
+      return reason.code === "no-trial-quality-checks" || reason.code === "no-completed-trials";
+    case "unable-to-evaluate":
+      return reason.code === "required-check-error" || reason.code === "required-metric-unavailable" || reason.code === "scores-incomplete";
+  }
+}
+function normalizeQualityReason(value, fallback, status, purpose, executionStatus) {
+  if (!isRecord(value) || typeof value.code !== "string" || typeof value.message !== "string") return fallback;
+  const reason = value;
+  return isQualityReasonCompatible(reason, status, purpose, executionStatus) ? reason : fallback;
+}
+function normalizeEvaluationTrial(value, purpose = "evaluation", evaluationMode = "pass-fail") {
+  if (!isRecord(value)) throw new Error("Evaluation trial must be an object.");
+  const legacyStatus = value.status;
+  const observations = Array.isArray(value.observations) ? value.observations : [];
+  const targetExecutionError = isTargetExecutionError(value, observations);
+  const executionStatus = isExecutionStatus(value.executionStatus) ? value.executionStatus : legacyStatus === "canceled" ? "canceled" : targetExecutionError ? "error" : legacyStatus === "error" && !observations.some(
+    (observation) => isRecord(observation) && observation.required !== false && observation.status === "error"
+  ) ? "error" : "completed";
+  const qualityStatus = purpose === "execution-benchmark" || executionStatus === "canceled" ? "not-evaluated" : executionStatus === "error" ? evaluationMode === "scoring" ? "unable-to-evaluate" : "failed" : evaluationMode === "scoring" ? scoringQualityFromObservations(observations) : isQualityStatus(value.qualityStatus) && isQualityStatusForMode(value.qualityStatus, evaluationMode) ? value.qualityStatus : legacyQualityFromObservations(observations, targetExecutionError);
+  const normalized = structuredClone(value);
+  delete normalized.status;
+  return {
+    ...normalized,
+    executionStatus,
+    qualityStatus,
+    qualityReason: normalizeQualityReason(
+      value.qualityReason,
+      executionStatus === "canceled" ? { code: "canceled", message: "The execution was canceled." } : purpose === "execution-benchmark" ? { code: "benchmark", message: "This run measured execution without evaluating output quality." } : reasonForQualityStatusInMode(qualityStatus, evaluationMode, executionStatus),
+      qualityStatus,
+      purpose,
+      executionStatus
+    )
+  };
+}
+function normalizeEvaluationAggregate(value, trials) {
+  if (!isRecord(value)) throw new Error("Evaluation aggregate must be an object.");
+  const normalized = structuredClone(value);
+  if (!isNormalizedScore(normalized.meanScore)) delete normalized.meanScore;
+  if (trials) {
+    const completed = trials.filter((trial) => trial.executionStatus === "completed");
+    const evaluated2 = completed.filter((trial) => trial.qualityStatus === "passed" || trial.qualityStatus === "failed");
+    const passed2 = evaluated2.filter((trial) => trial.qualityStatus === "passed");
+    const failed2 = evaluated2.filter((trial) => trial.qualityStatus === "failed");
+    const notEvaluated2 = completed.filter((trial) => trial.qualityStatus === "not-evaluated");
+    const unable2 = completed.filter((trial) => trial.qualityStatus === "unable-to-evaluate");
+    const scored = completed.filter((trial) => trial.qualityStatus === "scored");
+    return {
+      ...normalized,
+      trialCount: trials.length,
+      evaluatedTrialCount: evaluated2.length,
+      notEvaluatedTrialCount: notEvaluated2.length,
+      unableToEvaluateTrialCount: unable2.length,
+      passedTrialCount: passed2.length,
+      failedTrialCount: failed2.length,
+      erroredTrialCount: trials.filter((trial) => trial.executionStatus === "error").length,
+      canceledTrialCount: trials.filter((trial) => trial.executionStatus === "canceled").length,
+      ...scored.length > 0 || normalized.scoredTrialCount !== void 0 ? { scoredTrialCount: scored.length, missingScoreTrialCount: trials.length - scored.length } : {},
+      passRate: evaluated2.length === 0 ? 0 : passed2.length / evaluated2.length
+    };
+  }
+  const trialCount = Number(value.trialCount ?? 0);
+  const passed = Number(value.passedTrialCount ?? 0);
+  const failed = Number(value.failedTrialCount ?? 0);
+  const errored = Number(value.erroredTrialCount ?? 0);
+  const canceled = Number(value.canceledTrialCount ?? 0);
+  const evaluated = Number(value.evaluatedTrialCount ?? passed + failed);
+  const unable = Number(value.unableToEvaluateTrialCount ?? 0);
+  const notEvaluated = Number(
+    value.notEvaluatedTrialCount ?? Math.max(0, trialCount - evaluated - unable - errored - canceled)
+  );
+  return {
+    ...normalized,
+    evaluatedTrialCount: evaluated,
+    notEvaluatedTrialCount: notEvaluated,
+    unableToEvaluateTrialCount: unable,
+    passRate: evaluated === 0 ? 0 : passed / evaluated
+  };
+}
+function withoutAuthoritativeCost(aggregate2) {
+  const normalized = { ...aggregate2 };
+  delete normalized.totalCostUsd;
+  delete normalized.averageCostUsd;
+  return normalized;
+}
+function normalizeEvaluationBaselineSnapshot(value) {
+  if (!isRecord(value)) throw new Error("Evaluation baseline snapshot must be an object.");
+  const accountingStatus = isAccountingStatus(value.accountingStatus) ? value.accountingStatus : isRecord(value.provenance) && value.provenance.accountingComplete === false ? "partial" : "complete";
+  const aggregate2 = normalizeEvaluationAggregate(value.aggregate);
+  const purpose = isPurpose(value.purpose) ? value.purpose : "evaluation";
+  const evaluationMode = isEvaluationMode(value.evaluationMode) ? value.evaluationMode : "pass-fail";
+  const hasCompleteScoringAggregate = aggregate2.trialCount > 0 && aggregate2.scoredTrialCount === aggregate2.trialCount && aggregate2.missingScoreTrialCount === 0 && aggregate2.meanScore !== void 0;
+  const qualityStatus = purpose === "execution-benchmark" ? "not-evaluated" : evaluationMode === "scoring" ? hasCompleteScoringAggregate ? "scored" : "unable-to-evaluate" : isQualityStatus(value.qualityStatus) && isQualityStatusForMode(value.qualityStatus, evaluationMode) ? value.qualityStatus : aggregate2.failedTrialCount > 0 || aggregate2.erroredTrialCount > 0 ? "failed" : aggregate2.evaluatedTrialCount > 0 ? "passed" : "not-evaluated";
+  const qualityReasonFallback = purpose === "execution-benchmark" ? { code: "benchmark", message: "This run measured execution without evaluating output quality." } : reasonForQualityStatusInMode(qualityStatus, evaluationMode);
+  return {
+    ...structuredClone(value),
+    purpose,
+    evaluationMode,
+    qualityStatus,
+    qualityReason: normalizeQualityReason(value.qualityReason, qualityReasonFallback, qualityStatus, purpose),
+    accountingStatus,
+    aggregate: accountingStatus === "partial" ? withoutAuthoritativeCost(aggregate2) : aggregate2
+  };
+}
+function normalizeEvaluationRun(value) {
+  if (!isRecord(value)) throw new Error("Evaluation run must be an object.");
+  const purpose = isPurpose(value.purpose) ? value.purpose : "evaluation";
+  const evaluationMode = isEvaluationMode(value.evaluationMode) ? value.evaluationMode : "pass-fail";
+  const executionStatus = isRunExecutionStatus(value.executionStatus) ? value.executionStatus : typeof value.completedAt === "string" ? "completed" : "running";
+  const trials = Array.isArray(value.trials) ? value.trials.map((trial) => normalizeEvaluationTrial(trial, purpose, evaluationMode)) : [];
+  const accountingStatus = isAccountingStatus(value.accountingStatus) ? value.accountingStatus : isRecord(value.provenance) && value.provenance.accountingComplete === false ? "partial" : "complete";
+  let qualityStatus;
+  if (purpose === "execution-benchmark" || executionStatus === "canceled") {
+    qualityStatus = "not-evaluated";
+  } else if (executionStatus === "error") {
+    qualityStatus = evaluationMode === "scoring" ? "unable-to-evaluate" : "failed";
+  } else if (executionStatus === "queued" || executionStatus === "running") {
+    qualityStatus = "not-evaluated";
+  } else if (evaluationMode === "scoring") {
+    const scored = trials.filter((trial) => trial.qualityStatus === "scored").length;
+    qualityStatus = scored > 0 && scored === trials.length ? "scored" : "unable-to-evaluate";
+  } else if (isQualityStatus(value.qualityStatus) && isQualityStatusForMode(value.qualityStatus, evaluationMode)) {
+    qualityStatus = value.qualityStatus;
+  } else if (trials.some((trial) => trial.executionStatus === "error" || trial.qualityStatus === "failed")) {
+    qualityStatus = "failed";
+  } else if (trials.some((trial) => trial.qualityStatus === "unable-to-evaluate")) {
+    qualityStatus = "unable-to-evaluate";
+  } else if (trials.some((trial) => trial.qualityStatus === "passed")) {
+    qualityStatus = "passed";
+  } else if (value.verdict === "fail") {
+    qualityStatus = "failed";
+  } else {
+    qualityStatus = "not-evaluated";
+  }
+  const qualityReasonFallback = executionStatus === "canceled" ? { code: "canceled", message: "The evaluation run was canceled." } : executionStatus === "queued" || executionStatus === "running" ? { code: "in-progress", message: "The run is still in progress." } : purpose === "execution-benchmark" ? { code: "benchmark", message: "This run measured execution without evaluating output quality." } : (executionStatus === "error" || trials.some((trial) => trial.executionStatus === "error")) && qualityStatus === "failed" ? { code: "target-error", message: "One or more target graph executions failed." } : reasonForQualityStatusInMode(qualityStatus, evaluationMode);
+  const provenance = isRecord(value.provenance) ? {
+    ...structuredClone(value.provenance),
+    accountingComplete: accountingStatus === "complete"
+  } : value.provenance;
+  const normalized = structuredClone(value);
+  delete normalized.verdict;
+  const aggregate2 = value.aggregate === void 0 ? void 0 : normalizeEvaluationAggregate(value.aggregate, trials);
+  return {
+    ...normalized,
+    version: 2,
+    purpose,
+    evaluationMode,
+    executionStatus,
+    qualityStatus,
+    qualityReason: normalizeQualityReason(
+      value.qualityReason,
+      qualityReasonFallback,
+      qualityStatus,
+      purpose,
+      executionStatus
+    ),
+    accountingStatus,
+    provenance,
+    trials,
+    thresholdResults: Array.isArray(value.thresholdResults) ? structuredClone(value.thresholdResults) : [],
+    ...aggregate2 === void 0 ? {} : { aggregate: accountingStatus === "partial" ? withoutAuthoritativeCost(aggregate2) : aggregate2 }
+  };
+}
+
+// src/dataTypes.ts
+var portableEvaluationDataTypes = [
+  "any",
+  "any[]",
+  "string",
+  "string[]",
+  "date",
+  "date[]",
+  "time",
+  "time[]",
+  "datetime",
+  "datetime[]",
+  "number",
+  "number[]",
+  "vector",
+  "vector[]",
+  "boolean",
+  "boolean[]",
+  "object",
+  "object[]"
+];
+var portableEvaluationDataTypeSet = new Set(portableEvaluationDataTypes);
+function isPortableEvaluationDataType(dataType) {
+  return portableEvaluationDataTypeSet.has(dataType);
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isArrayOf(value, predicate) {
+  return Array.isArray(value) && value.every(predicate);
+}
+function isEvaluationValueCompatibleWithDataType(value, dataType) {
+  try {
+    assertPortableJson(value);
+  } catch {
+    return false;
+  }
+  if (dataType === "any") return true;
+  if (dataType === "any[]") return Array.isArray(value);
+  if (dataType === "string" || dataType === "date" || dataType === "time" || dataType === "datetime") {
+    return typeof value === "string";
+  }
+  if (dataType === "string[]" || dataType === "date[]" || dataType === "time[]" || dataType === "datetime[]") {
+    return isArrayOf(value, (item) => typeof item === "string");
+  }
+  if (dataType === "number") return isFiniteNumber(value);
+  if (dataType === "number[]" || dataType === "vector") return isArrayOf(value, isFiniteNumber);
+  if (dataType === "vector[]") {
+    return isArrayOf(value, (item) => isArrayOf(item, isFiniteNumber));
+  }
+  if (dataType === "boolean") return typeof value === "boolean";
+  if (dataType === "boolean[]") return isArrayOf(value, (item) => typeof item === "boolean");
+  if (dataType === "object") return isObject(value);
+  if (dataType === "object[]") return isArrayOf(value, isObject);
+  return false;
+}
+function areEvaluationDataTypesCompatible(sourceDataType, targetDataType) {
+  return sourceDataType === "any" || targetDataType === "any" || sourceDataType === targetDataType;
+}
+function assertEvaluationDatasetValuesMatchDeclaredTypes(dataset) {
+  const fieldsById = new Map(dataset.fields.map((field) => [field.id, field]));
+  for (const [fieldIndex, field] of dataset.fields.entries()) {
+    if (!isPortableEvaluationDataType(field.dataType)) {
+      throw new Error(
+        `fields[${fieldIndex}].dataType "${field.dataType}" has no portable evaluation JSON representation.`
+      );
+    }
+  }
+  for (const [caseIndex, testCase] of dataset.cases.entries()) {
+    for (const [fieldId, value] of Object.entries(testCase.values)) {
+      const field = fieldsById.get(fieldId);
+      if (field && !isEvaluationValueCompatibleWithDataType(value, field.dataType)) {
+        throw new Error(
+          `cases[${caseIndex}].values.${fieldId} is not compatible with declared type "${field.dataType}".`
+        );
+      }
+    }
+  }
+}
+
+// src/runner.ts
+var import_rivet2_core = require("@valerypopoff/rivet2-core");
+var DEFAULT_CONCURRENCY = 4;
+var MAX_CONCURRENCY = 32;
+var LEGACY_EVALUATOR_INPUT_IDS = ["case", "inputs", "expected", "outputs", "run"];
+function hasAuthoritativeEvaluationCriteria(suite) {
+  var _a;
+  if (getEvaluationSuiteMode(suite) === "scoring") return suite.evaluators.length > 0;
+  return suite.assertions.some((assertion) => assertion.required !== false) || suite.evaluators.some((evaluator) => evaluator.required !== false) || (((_a = suite.thresholds) == null ? void 0 : _a.length) ?? 0) > 0;
+}
+function getEvaluationSuiteMode(suite) {
+  return suite.evaluationMode === "scoring" ? "scoring" : "pass-fail";
+}
+function usesLegacyEvaluatorInputEnvelope(evaluator, graphInputIds) {
+  return evaluator.inputBindings === void 0 && LEGACY_EVALUATOR_INPUT_IDS.every((inputId) => graphInputIds.includes(inputId));
+}
+async function runEvaluationWorkPool(options) {
+  if (!Number.isSafeInteger(options.concurrency) || options.concurrency < 1) {
+    throw new Error("Evaluation worker-pool concurrency must be a positive safe integer.");
+  }
+  const results = Array.from({ length: options.work.length });
+  let nextIndex = 0;
+  const worker = async () => {
+    var _a, _b;
+    while (true) {
+      if ((_a = options.signal) == null ? void 0 : _a.aborted) return;
+      const index = nextIndex++;
+      if (index >= options.work.length) return;
+      const work = options.work[index];
+      const result = await options.execute(work, index);
+      results[index] = result;
+      (_b = options.onSettled) == null ? void 0 : _b.call(options, result, index, results);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(options.concurrency, options.work.length) }, worker));
+  return results;
+}
+function createEmptyMetrics() {
+  return { durationMs: 0 };
+}
+var executionMetricCountKeys = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "reasoningTokens",
+  "modelCallCount",
+  "toolCallCount",
+  "toolFailureCount"
+];
+function cloneExecutionMetrics(value, path) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${path} must be an object.`);
+  }
+  if (!Number.isFinite(value.durationMs) || value.durationMs < 0) {
+    throw new Error(`${path}.durationMs must be a non-negative finite number.`);
+  }
+  const metrics = { durationMs: value.durationMs };
+  for (const key of executionMetricCountKeys) {
+    const count = value[key];
+    if (count === void 0) continue;
+    if (!Number.isSafeInteger(count) || count < 0) {
+      throw new Error(`${path}.${key} must be a non-negative safe integer.`);
+    }
+    metrics[key] = count;
+  }
+  if (value.costUsd !== void 0) {
+    if (!Number.isFinite(value.costUsd) || value.costUsd < 0) {
+      throw new Error(`${path}.costUsd must be a non-negative finite number.`);
+    }
+    metrics.costUsd = value.costUsd;
+  }
+  if (value.hasUnknownCost !== void 0) {
+    if (typeof value.hasUnknownCost !== "boolean") throw new Error(`${path}.hasUnknownCost must be a boolean.`);
+    metrics.hasUnknownCost = value.hasUnknownCost;
+  }
+  return metrics;
+}
+function tryCloneExecutionMetrics(value, path) {
+  if (value === void 0) return void 0;
+  try {
+    return cloneExecutionMetrics(value, path);
+  } catch {
+    return void 0;
+  }
+}
+function cloneOptionalPortableJson(value, path) {
+  if (value === void 0) return void 0;
+  assertPortableJson(value, path);
+  return clonePortableJson(value);
+}
+function tryCloneOptionalPortableJson(value, path) {
+  try {
+    return cloneOptionalPortableJson(value, path);
+  } catch {
+    return void 0;
+  }
+}
+function finalizeEvaluationRecordingRetention(run, policy = "failures-and-baselines", now = Date.now()) {
+  const retainAll = policy === "all";
+  const finalize = (reference, failed) => {
+    const retention = retainAll ? "retained" : failed ? "failure" : "temporary";
+    return {
+      id: reference.id,
+      retention,
+      ...retention === "temporary" ? { expiresAt: new Date(now + 24 * 60 * 60 * 1e3).toISOString() } : {}
+    };
+  };
+  return {
+    ...run,
+    trials: run.trials.map((trial) => {
+      const targetFailed = trial.executionStatus !== "completed" || trial.observations.some(
+        (observation) => observation.kind === "assertion" && observation.required && (observation.status === "failed" || observation.status === "error")
+      );
+      return {
+        ...trial,
+        ...trial.recording === void 0 ? {} : { recording: finalize(trial.recording, targetFailed) },
+        observations: trial.observations.map((observation) => ({
+          ...observation,
+          ...observation.recording === void 0 ? {} : {
+            recording: finalize(
+              observation.recording,
+              observation.status === "failed" || observation.status === "error"
+            )
+          }
+        }))
+      };
+    })
+  };
+}
+function mergeMetrics(...metrics) {
+  const numberKeys = [
+    "durationMs",
+    "inputTokens",
+    "outputTokens",
+    "cachedInputTokens",
+    "reasoningTokens",
+    "modelCallCount",
+    "toolCallCount",
+    "toolFailureCount",
+    "costUsd"
+  ];
+  const merged = { durationMs: 0 };
+  for (const key of numberKeys) {
+    const value = metrics.reduce((sum, item) => sum + (item[key] ?? 0), 0);
+    if (value !== 0 || key === "durationMs") merged[key] = value;
+  }
+  if (metrics.some((item) => item.hasUnknownCost)) merged.hasUnknownCost = true;
+  return merged;
+}
+function makeId(prefix) {
+  const cryptoValue = globalThis.crypto;
+  if (cryptoValue == null ? void 0 : cryptoValue.randomUUID) return `${prefix}-${cryptoValue.randomUUID()}`;
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function throwIfAborted(signal) {
+  if (signal == null ? void 0 : signal.aborted) throw signal.reason ?? new DOMException("Evaluation canceled.", "AbortError");
+}
+function isAbort(error) {
+  return error instanceof DOMException && error.name === "AbortError" || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function resolveSuite(data, id) {
+  const suite = data.suites.find((candidate) => candidate.id === id);
+  if (!suite) throw new Error(`Evaluation suite "${id}" does not exist.`);
+  return suite;
+}
+function validateDefinitionIds(suite) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [kind, definitions] of [
+    ["quality check", suite.assertions],
+    ["evaluator graph", suite.evaluators],
+    ["threshold", suite.thresholds ?? []]
+  ]) {
+    for (const definition of definitions) {
+      if (typeof definition.id !== "string" || definition.id.trim().length === 0) {
+        throw new Error(`Every evaluation ${kind} must have a non-empty id.`);
+      }
+      const previous = seen.get(definition.id);
+      if (previous) {
+        throw new Error(`Evaluation ${kind} id "${definition.id}" duplicates a ${previous} id.`);
+      }
+      seen.set(definition.id, kind);
+    }
+  }
+}
+var rateThresholdMetrics = /* @__PURE__ */ new Set([
+  "pass-rate",
+  "mean-score",
+  "target-error-rate",
+  "evaluator-error-rate",
+  "tool-failure-rate"
+]);
+function formatThresholdResultValue(metric, operator, value) {
+  return operator === "max-regression" || rateThresholdMetrics.has(metric) ? `${Number((value * 100).toFixed(4))}%` : String(value);
+}
+function validateThresholdConfiguration(threshold) {
+  const { metric, operator, value } = threshold;
+  if (typeof metric !== "string" || metric.length === 0) {
+    throw new Error(`Evaluation threshold "${threshold.id}" must select a metric.`);
+  }
+  if (typeof operator !== "string") {
+    throw new Error(`Evaluation threshold "${threshold.id}" must select an operator.`);
+  }
+  if (!Number.isFinite(value)) throw new Error(`Evaluation threshold "${threshold.id}" must use a finite value.`);
+  if (rateThresholdMetrics.has(metric) && (value < 0 || value > 1)) {
+    throw new Error(`Evaluation threshold "${threshold.id}" must use a value from 0 to 1.`);
+  }
+  if (["average-cost", "total-cost", "average-latency-ms", "p95-latency-ms"].includes(metric) && value < 0) {
+    throw new Error(`Evaluation threshold "${threshold.id}" cannot use a negative value.`);
+  }
+  if (operator === "max-regression") {
+    if (value < 0) throw new Error(`Evaluation regression threshold "${threshold.id}" cannot be negative.`);
+    return;
+  }
+  const expectedOperator = metric === "pass-rate" || metric === "mean-score" ? "at-least" : metric.startsWith("custom:") ? void 0 : "at-most";
+  if (expectedOperator !== void 0 && operator !== expectedOperator || expectedOperator === void 0 && operator !== "at-least" && operator !== "at-most") {
+    throw new Error(`Evaluation threshold "${threshold.id}" uses an incompatible operator for "${metric}".`);
+  }
+}
+function validateSuite(project, suite, dataset, purpose) {
+  var _a;
+  const evaluationMode = getEvaluationSuiteMode(suite);
+  validateDefinitionIds(suite);
+  if (dataset.projectId !== void 0 && dataset.projectId !== project.metadata.id) {
+    throw new Error(`Evaluation dataset "${dataset.name}" belongs to a different project.`);
+  }
+  if (suite.datasetId !== dataset.id)
+    throw new Error(`Suite "${suite.name}" is bound to a different evaluation dataset.`);
+  const graph = project.graphs[suite.targetGraphId];
+  if (!graph) throw new Error(`Target graph "${suite.targetGraphId}" does not exist.`);
+  const graphInputs = graph.nodes.filter((node) => node.type === "graphInput");
+  const graphInputIds = graphInputs.map((input) => input.data.id);
+  if (new Set(graphInputIds).size !== graphInputIds.length) {
+    throw new Error(`Target graph "${suite.targetGraphId}" has duplicate Graph Input ids.`);
+  }
+  const graphOutputs = graph.nodes.filter((node) => node.type === "graphOutput");
+  const graphOutputIds = graphOutputs.map((output) => output.data.id);
+  if (new Set(graphOutputIds).size !== graphOutputIds.length) {
+    throw new Error(`Target graph "${suite.targetGraphId}" has duplicate Graph Output ids.`);
+  }
+  const inputIds = new Set(graphInputIds);
+  const graphInputsById = new Map(graphInputs.map((input) => [input.data.id, input]));
+  const fields = new Map(dataset.fields.map((field) => [field.id, field]));
+  if (fields.size !== dataset.fields.length)
+    throw new Error(`Evaluation dataset "${dataset.name}" has duplicate field ids.`);
+  const boundGraphInputs = /* @__PURE__ */ new Set();
+  for (const binding of suite.inputBindings) {
+    if (boundGraphInputs.has(binding.graphInputId)) {
+      throw new Error(`Target graph input "${binding.graphInputId}" is bound more than once.`);
+    }
+    boundGraphInputs.add(binding.graphInputId);
+    if (!inputIds.has(binding.graphInputId))
+      throw new Error(`Graph input "${binding.graphInputId}" does not exist on the target graph.`);
+    const field = fields.get(binding.datasetFieldId);
+    if (!field) throw new Error(`Evaluation dataset field "${binding.datasetFieldId}" does not exist.`);
+    if (field.role !== "input")
+      throw new Error(`Dataset field "${field.name}" must have the input role to bind it to a graph input.`);
+    const graphInput = graphInputsById.get(binding.graphInputId);
+    if (!areEvaluationDataTypesCompatible(field.dataType, graphInput.data.dataType)) {
+      throw new Error(
+        `Dataset field "${field.name}" (${field.dataType}) is not compatible with graph input "${graphInput.data.id}" (${graphInput.data.dataType}).`
+      );
+    }
+  }
+  for (const input of graphInputs) {
+    if (suite.inputBindings.some((binding) => binding.graphInputId === input.data.id)) continue;
+    if (input.data.defaultValue === void 0 || input.data.useDefaultValueInput) {
+      throw new Error(
+        `Target graph input "${input.data.id}" must be bound to an evaluation dataset field or have a static graph default.`
+      );
+    }
+  }
+  for (const testCase of dataset.cases.filter((candidate) => candidate.enabled !== false)) {
+    for (const [fieldId, value] of Object.entries(testCase.values)) {
+      const field = fields.get(fieldId);
+      if (!field) {
+        throw new Error(`Case "${testCase.name}" supplies unknown dataset field "${fieldId}".`);
+      }
+      assertPortableJson(value, `case.${testCase.id}.${fieldId}`);
+      if (!isEvaluationValueCompatibleWithDataType(value, field.dataType)) {
+        throw new Error(
+          `Case "${testCase.name}" value for "${field.name}" is not compatible with its declared ${field.dataType} type.`
+        );
+      }
+    }
+    for (const binding of suite.inputBindings) {
+      const value = testCase.values[binding.datasetFieldId];
+      if (value === void 0) {
+        const field = fields.get(binding.datasetFieldId);
+        throw new Error(`Case "${testCase.name}" has no saved value for bound input field "${field.name}".`);
+      }
+      const graphInput = graphInputsById.get(binding.graphInputId);
+      if (!isEvaluationValueCompatibleWithDataType(value, graphInput.data.dataType)) {
+        throw new Error(
+          `Case "${testCase.name}" value for "${binding.datasetFieldId}" is not compatible with target graph input "${binding.graphInputId}" (${graphInput.data.dataType}).`
+        );
+      }
+    }
+    for (const field of dataset.fields) {
+      const requiredForThisRun = field.required && (purpose === "evaluation" || field.role === "input");
+      if (requiredForThisRun && testCase.values[field.id] === void 0) {
+        throw new Error(`Case "${testCase.name}" is missing required field "${field.name}".`);
+      }
+    }
+  }
+  if (purpose === "evaluation" && evaluationMode === "pass-fail") {
+    for (const assertion of suite.assertions) {
+      const outputId = getEvaluationTopLevelOutputId(assertion.outputPath);
+      if (assertion.outputPath.trim() !== "$" && outputId === void 0) {
+        throw new Error(
+          `Assertion "${assertion.name}" output path must start with a named target Graph Output.`
+        );
+      }
+      if (outputId !== void 0 && !graphOutputIds.includes(outputId)) {
+        throw new Error(`Assertion "${assertion.name}" references missing target output "${outputId}".`);
+      }
+      if (assertion.expected.kind === "dataset-field") {
+        const field = fields.get(assertion.expected.fieldId);
+        if (!field) throw new Error(`Assertion "${assertion.name}" references a missing expected dataset field.`);
+        if (field.role !== "expected")
+          throw new Error(`Assertion "${assertion.name}" must reference a dataset field with the expected role.`);
+        for (const testCase of dataset.cases.filter((candidate) => candidate.enabled !== false)) {
+          const expected = testCase.values[field.id];
+          if (expected === void 0) {
+            throw new Error(`Case "${testCase.name}" is missing expected field "${field.name}".`);
+          }
+          validateEvaluationAssertionConfiguration(assertion, expected);
+        }
+      } else {
+        validateEvaluationAssertionConfiguration(assertion, assertion.expected.value);
+      }
+    }
+  }
+  if (((_a = suite.configuration) == null ? void 0 : _a.seed) !== void 0) {
+    const seedInputId = suite.configuration.seedGraphInputId;
+    if (!seedInputId) throw new Error("A suite seed requires selecting the target graph input that receives it.");
+    const seedInput = graphInputsById.get(seedInputId);
+    if (!seedInput)
+      throw new Error(`The selected seed graph input "${seedInputId}" does not exist on the target graph.`);
+    if (seedInput.data.dataType !== "number" && seedInput.data.dataType !== "any") {
+      throw new Error(`The selected seed graph input "${seedInputId}" must accept a number.`);
+    }
+    if (suite.inputBindings.some((binding) => binding.graphInputId === seedInputId)) {
+      throw new Error(`The selected seed graph input "${seedInputId}" cannot also be bound to a dataset field.`);
+    }
+  }
+  for (const evaluator of purpose === "evaluation" ? suite.evaluators : []) {
+    if (evaluator.scoreWeight !== void 0 && (!Number.isFinite(evaluator.scoreWeight) || evaluator.scoreWeight <= 0)) {
+      throw new Error(`Evaluator graph "${evaluator.name}" score weight must be a positive finite number.`);
+    }
+    const evaluatorGraph = project.graphs[evaluator.graphId];
+    if (!evaluatorGraph) throw new Error(`Evaluator graph "${evaluator.graphId}" does not exist.`);
+    const evaluatorGraphInputs = evaluatorGraph.nodes.filter(
+      (node) => node.type === "graphInput"
+    );
+    const evaluatorInputIds = evaluatorGraphInputs.map((input) => input.data.id);
+    if (new Set(evaluatorInputIds).size !== evaluatorInputIds.length) {
+      throw new Error(`Evaluator graph "${evaluator.name}" has duplicate Graph Input ids.`);
+    }
+    const evaluatorOutputIds = evaluatorGraph.nodes.filter((node) => node.type === "graphOutput").map((output) => output.data.id);
+    if (new Set(evaluatorOutputIds).size !== evaluatorOutputIds.length) {
+      throw new Error(`Evaluator graph "${evaluator.name}" has duplicate Graph Output ids.`);
+    }
+    const evaluatorInputsById = new Map(evaluatorGraphInputs.map((input) => [input.data.id, input]));
+    const usesLegacyInputs = usesLegacyEvaluatorInputEnvelope(evaluator, evaluatorInputIds);
+    if (usesLegacyInputs) {
+      for (const inputId of LEGACY_EVALUATOR_INPUT_IDS) {
+        const evaluatorInput = evaluatorInputsById.get(inputId);
+        if (evaluatorInput.data.dataType !== "object" && evaluatorInput.data.dataType !== "any") {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" legacy input "${inputId}" must accept the object or any data type.`
+          );
+        }
+      }
+      for (const evaluatorInput of evaluatorGraphInputs) {
+        if (LEGACY_EVALUATOR_INPUT_IDS.includes(evaluatorInput.data.id)) {
+          continue;
+        }
+        if (evaluatorInput.data.defaultValue === void 0 || evaluatorInput.data.useDefaultValueInput) {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" input "${evaluatorInput.data.id}" needs a direct binding or a static graph default.`
+          );
+        }
+      }
+    } else {
+      const evaluatorBindings = evaluator.inputBindings ?? [];
+      const boundEvaluatorInputs = /* @__PURE__ */ new Set();
+      for (const binding of evaluatorBindings) {
+        if (boundEvaluatorInputs.has(binding.graphInputId)) {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" input "${binding.graphInputId}" is bound more than once.`
+          );
+        }
+        boundEvaluatorInputs.add(binding.graphInputId);
+        const evaluatorInput = evaluatorInputsById.get(binding.graphInputId);
+        if (!evaluatorInput) {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" input "${binding.graphInputId}" does not exist on the selected graph.`
+          );
+        }
+        let sourceDataType;
+        if (binding.source.kind === "dataset-field") {
+          const field = fields.get(binding.source.fieldId);
+          if (!field) {
+            throw new Error(
+              `Evaluator graph "${evaluator.name}" binding references missing dataset field "${binding.source.fieldId}".`
+            );
+          }
+          sourceDataType = field.dataType;
+          for (const testCase of dataset.cases.filter((candidate) => candidate.enabled !== false)) {
+            const value = testCase.values[field.id];
+            if (value === void 0) {
+              throw new Error(
+                `Case "${testCase.name}" has no saved value for evaluator input "${binding.graphInputId}" from dataset field "${field.name}".`
+              );
+            }
+            if (!isEvaluationValueCompatibleWithDataType(value, evaluatorInput.data.dataType)) {
+              throw new Error(
+                `Case "${testCase.name}" value from dataset field "${field.name}" is not compatible with evaluator input "${binding.graphInputId}" (${evaluatorInput.data.dataType}).`
+              );
+            }
+          }
+        } else if (binding.source.kind === "target-output") {
+          const outputId = binding.source.outputId;
+          const targetOutput = graph.nodes.find(
+            (node) => node.type === "graphOutput" && node.data.id === outputId
+          );
+          if (!targetOutput) {
+            throw new Error(
+              `Evaluator graph "${evaluator.name}" binding references missing target output "${outputId}".`
+            );
+          }
+          sourceDataType = targetOutput.data.dataType;
+        } else if (binding.source.kind === "context") {
+          sourceDataType = "object";
+        } else {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" input "${binding.graphInputId}" uses an unsupported source.`
+          );
+        }
+        if (!areEvaluationDataTypesCompatible(sourceDataType, evaluatorInput.data.dataType)) {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" source for input "${binding.graphInputId}" (${sourceDataType}) is not compatible with ${evaluatorInput.data.dataType}.`
+          );
+        }
+      }
+      for (const evaluatorInput of evaluatorGraphInputs) {
+        if (boundEvaluatorInputs.has(evaluatorInput.data.id)) continue;
+        if (evaluatorInput.data.defaultValue === void 0 || evaluatorInput.data.useDefaultValueInput) {
+          throw new Error(
+            `Evaluator graph "${evaluator.name}" input "${evaluatorInput.data.id}" must be bound to a target output, dataset field, or evaluation context value, or have a static graph default.`
+          );
+        }
+      }
+    }
+    const resultOutput = evaluatorGraph.nodes.find(
+      (node) => node.type === "graphOutput" && node.data.id === "result"
+    );
+    if (!resultOutput) {
+      throw new Error(`Evaluator graph "${evaluator.name}" must declare a Graph Output named "result".`);
+    }
+    if (resultOutput.data.dataType !== "object" && resultOutput.data.dataType !== "any") {
+      throw new Error(`Evaluator graph "${evaluator.name}" output "result" must have the object data type.`);
+    }
+  }
+  if (purpose === "evaluation" && evaluationMode === "pass-fail") {
+    const hasRequiredPerTrialCheck = suite.assertions.some((assertion) => assertion.required !== false) || suite.evaluators.some((evaluator) => evaluator.required !== false);
+    const hasEvaluator = suite.evaluators.length > 0;
+    for (const threshold of suite.thresholds ?? []) {
+      validateThresholdConfiguration(threshold);
+      const metric = threshold.metric;
+      const supportedExecutionMetric = [
+        "target-error-rate",
+        "tool-failure-rate",
+        "average-cost",
+        "total-cost",
+        "average-latency-ms",
+        "p95-latency-ms"
+      ].includes(metric);
+      const supportedEvaluatorMetric = metric === "mean-score" || metric === "evaluator-error-rate" || metric.startsWith("custom:") && metric.length > "custom:".length;
+      if (metric === "pass-rate" && !hasRequiredPerTrialCheck) {
+        throw new Error("A pass-rate threshold requires at least one required quality check or evaluator graph.");
+      }
+      if (supportedEvaluatorMetric && !hasEvaluator) {
+        throw new Error(`The "${metric}" threshold requires at least one evaluator graph.`);
+      }
+      if (metric !== "pass-rate" && !supportedExecutionMetric && !supportedEvaluatorMetric) {
+        throw new Error(`Evaluation threshold metric "${metric}" is not supported.`);
+      }
+    }
+  } else if (purpose === "evaluation" && suite.evaluators.length === 0) {
+    throw new Error("A scoring evaluation suite requires at least one evaluator graph.");
+  }
+  const caseIds = new Set(dataset.cases.map((testCase) => testCase.id));
+  if (caseIds.size !== dataset.cases.length)
+    throw new Error(`Evaluation dataset "${dataset.name}" has duplicate case ids.`);
+  if (!dataset.cases.some((testCase) => testCase.enabled !== false)) {
+    throw new Error(`Evaluation dataset "${dataset.name}" has no enabled cases.`);
+  }
+  const configuration = suite.configuration;
+  if ((configuration == null ? void 0 : configuration.trialCount) !== void 0 && (!Number.isSafeInteger(configuration.trialCount) || configuration.trialCount < 1)) {
+    throw new Error("Evaluation trial count must be a positive safe integer.");
+  }
+  if ((configuration == null ? void 0 : configuration.concurrency) !== void 0 && (!Number.isSafeInteger(configuration.concurrency) || configuration.concurrency < 1 || configuration.concurrency > MAX_CONCURRENCY)) {
+    throw new Error(`Evaluation concurrency must be a whole number from 1 to ${MAX_CONCURRENCY}.`);
+  }
+  if ((configuration == null ? void 0 : configuration.timeoutMs) !== void 0 && (!Number.isFinite(configuration.timeoutMs) || configuration.timeoutMs <= 0)) {
+    throw new Error("Evaluation timeout must be a positive number of milliseconds.");
+  }
+  if ((configuration == null ? void 0 : configuration.seed) !== void 0 && (!Number.isSafeInteger(configuration.seed) || configuration.seed < 0)) {
+    throw new Error("Evaluation seed must be a non-negative safe integer.");
+  }
+}
+function resolveCaseInputs(suite, dataset, testCase, purpose) {
+  const fields = new Map(dataset.fields.map((field) => [field.id, field]));
+  const inputs = {};
+  const expected = {};
+  for (const field of dataset.fields) {
+    const value = testCase.values[field.id];
+    if (value === void 0) {
+      const requiredForThisRun = field.required && (purpose === "evaluation" || field.role === "input");
+      if (requiredForThisRun) {
+        throw new Error(`Case "${testCase.name}" is missing required field "${field.name}".`);
+      }
+      continue;
+    }
+    assertPortableJson(value, `case.${field.id}`);
+    if (field.role === "expected") expected[field.id] = clonePortableJson(value);
+  }
+  for (const binding of suite.inputBindings) {
+    const field = fields.get(binding.datasetFieldId);
+    const value = testCase.values[field.id];
+    if (value === void 0) {
+      throw new Error(`Case "${testCase.name}" has no saved value for bound input field "${field.name}".`);
+    }
+    if (!isEvaluationValueCompatibleWithDataType(value, field.dataType)) {
+      throw new Error(
+        `Case "${testCase.name}" input "${field.name}" is not compatible with its declared ${field.dataType} type.`
+      );
+    }
+    inputs[binding.graphInputId] = clonePortableJson(value);
+  }
+  return { inputs, expected };
+}
+function createEvaluatorCaseInput(testCase) {
+  return {
+    id: testCase.id,
+    name: testCase.name,
+    enabled: testCase.enabled !== false,
+    ...testCase.tags === void 0 ? {} : { tags: [...testCase.tags] },
+    ...testCase.note === void 0 ? {} : { note: testCase.note },
+    values: clonePortableJson(testCase.values)
+  };
+}
+function createEvaluatorGraphInputs(input) {
+  var _a;
+  const { evaluator, project, testCase, targetInputs, expected, targetOutputs, run } = input;
+  const contextValues = {
+    case: createEvaluatorCaseInput(testCase),
+    inputs: clonePortableJson(targetInputs),
+    expected: clonePortableJson(expected),
+    outputs: clonePortableJson(targetOutputs),
+    run: clonePortableJson(run)
+  };
+  const evaluatorGraphInputs = ((_a = project.graphs[evaluator.graphId]) == null ? void 0 : _a.nodes.filter((node) => node.type === "graphInput")) ?? [];
+  const evaluatorGraphInputIds = evaluatorGraphInputs.map((node) => node.data.id);
+  if (usesLegacyEvaluatorInputEnvelope(evaluator, evaluatorGraphInputIds)) return contextValues;
+  const evaluatorInputsById = new Map(evaluatorGraphInputs.map((node) => [node.data.id, node]));
+  const evaluatorInputs = {};
+  for (const binding of evaluator.inputBindings ?? []) {
+    if (binding.source.kind === "dataset-field") {
+      const value = testCase.values[binding.source.fieldId];
+      if (value === void 0) {
+        throw new Error(
+          `Case "${testCase.name}" has no value for evaluator input "${binding.graphInputId}" from dataset field "${binding.source.fieldId}".`
+        );
+      }
+      evaluatorInputs[binding.graphInputId] = clonePortableJson(value);
+    } else if (binding.source.kind === "target-output") {
+      if (!Object.hasOwn(targetOutputs, binding.source.outputId)) {
+        throw new Error(
+          `Target graph did not produce output "${binding.source.outputId}" required by evaluator input "${binding.graphInputId}".`
+        );
+      }
+      const targetOutputValue = targetOutputs[binding.source.outputId];
+      const evaluatorInput = evaluatorInputsById.get(binding.graphInputId);
+      if (evaluatorInput && !isEvaluationValueCompatibleWithDataType(targetOutputValue, evaluatorInput.data.dataType)) {
+        throw new Error(
+          `Target output "${binding.source.outputId}" is not compatible with evaluator input "${binding.graphInputId}" (${evaluatorInput.data.dataType}).`
+        );
+      }
+      evaluatorInputs[binding.graphInputId] = clonePortableJson(targetOutputValue);
+    } else if (binding.source.kind === "context") {
+      evaluatorInputs[binding.graphInputId] = clonePortableJson(contextValues[binding.source.context]);
+    } else {
+      throw new Error(`Evaluator input "${binding.graphInputId}" uses an unsupported source.`);
+    }
+  }
+  return evaluatorInputs;
+}
+function hashStableText(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function deriveSeed(seed, caseId, trialIndex) {
+  if (seed == null) return void 0;
+  let value = seed >>> 0;
+  value = Math.imul(value ^ hashStableText(caseId), 73244475);
+  value = Math.imul(value ^ trialIndex + 1, 73244475);
+  return (value ^ value >>> 16) >>> 0;
+}
+function normalizeEvaluatorResult(value, evaluationMode) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error('Evaluator graph output "result" must be an object.');
+  }
+  if (evaluationMode === "pass-fail" && typeof value.passed !== "boolean") {
+    throw new Error('Evaluator graph output "result.passed" must be a boolean.');
+  }
+  const score = value.score;
+  if ((evaluationMode === "scoring" || score !== void 0) && (typeof score !== "number" || !Number.isFinite(score) || score < 0 || score > 100)) {
+    throw new Error(
+      'Evaluator graph output "result.score" must be a number from 0 to 100 (for example, return 85 for 85/100).'
+    );
+  }
+  if (value.message !== void 0 && typeof value.message !== "string") {
+    throw new Error('Evaluator graph output "result.message" must be a string.');
+  }
+  if (value.metrics !== void 0 && (typeof value.metrics !== "object" || value.metrics === null || Array.isArray(value.metrics))) {
+    throw new Error('Evaluator graph output "result.metrics" must be an object.');
+  }
+  const metrics = value.metrics;
+  if (metrics && Object.values(metrics).some((entry) => typeof entry !== "number" || !Number.isFinite(entry))) {
+    throw new Error('Evaluator graph output "result.metrics" values must be finite numbers.');
+  }
+  if (value.evidence !== void 0) assertPortableJson(value.evidence, "evaluator result.evidence");
+  return {
+    id: "",
+    kind: "graph",
+    name: "",
+    required: true,
+    status: evaluationMode === "scoring" ? "scored" : value.passed ? "passed" : "failed",
+    // Evaluator authors use the same 100-point scale shown by the UI. Runs
+    // retain normalized values so historical aggregation and thresholds stay
+    // backward compatible with existing evaluation records.
+    ...typeof score === "number" ? { score: score / 100 } : {},
+    ...typeof value.message === "string" ? { message: value.message } : {},
+    ...value.evidence !== void 0 ? { evidence: clonePortableJson(value.evidence) } : {},
+    ...metrics ? { metrics: clonePortableJson(metrics) } : {}
+  };
+}
+async function runWithTimeout(run, timeoutMs, outer) {
+  throwIfAborted(outer);
+  const controller = new AbortController();
+  let rejectCanceled;
+  const canceled = new Promise((_, reject) => {
+    rejectCanceled = reject;
+  });
+  const abort = () => {
+    const error = (outer == null ? void 0 : outer.reason) ?? new DOMException("Evaluation canceled.", "AbortError");
+    controller.abort(error);
+    rejectCanceled == null ? void 0 : rejectCanceled(error);
+  };
+  outer == null ? void 0 : outer.addEventListener("abort", abort, { once: true });
+  if (outer == null ? void 0 : outer.aborted) {
+    outer.removeEventListener("abort", abort);
+    throw outer.reason ?? new DOMException("Evaluation canceled.", "AbortError");
+  }
+  let timeout;
+  let timeoutPromise;
+  if (timeoutMs != null && timeoutMs > 0) {
+    timeoutPromise = new Promise((_, reject) => {
+      timeout = setTimeout(() => {
+        const error = new DOMException("Evaluation trial timed out.", "TimeoutError");
+        controller.abort(error);
+        reject(error);
+      }, timeoutMs);
+    });
+  }
+  const execution = run(controller.signal);
+  try {
+    return await Promise.race([execution, canceled, ...timeoutPromise ? [timeoutPromise] : []]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    outer == null ? void 0 : outer.removeEventListener("abort", abort);
+  }
+}
+async function runTrial(input) {
+  var _a, _b, _c, _d;
+  const { project, suite, dataset, purpose, testCase, caseIndex, trialIndex, runId, runGraph, signal } = input;
+  const evaluationMode = getEvaluationSuiteMode(suite);
+  const { inputs, expected } = resolveCaseInputs(suite, dataset, testCase, purpose);
+  const seed = deriveSeed((_a = suite.configuration) == null ? void 0 : _a.seed, testCase.id, trialIndex);
+  if (seed !== void 0 && ((_b = suite.configuration) == null ? void 0 : _b.seedGraphInputId)) inputs[suite.configuration.seedGraphInputId] = seed;
+  const metadata = {
+    evaluationRunId: runId,
+    suiteId: suite.id,
+    caseId: testCase.id,
+    trialIndex,
+    phase: "target"
+  };
+  let targetMetrics = createEmptyMetrics();
+  let evaluatorMetrics = createEmptyMetrics();
+  let outputs = {};
+  let targetError;
+  let recording;
+  let targetProviderAttempts;
+  const targetStartedAt = Date.now();
+  try {
+    throwIfAborted(signal);
+    const target = await runWithTimeout(
+      (attemptSignal) => runGraph({ project, graphId: suite.targetGraphId, inputs, signal: attemptSignal, metadata }),
+      (_c = suite.configuration) == null ? void 0 : _c.timeoutMs,
+      signal
+    );
+    targetMetrics = cloneExecutionMetrics(target.metrics, "target metrics");
+    assertPortableJson(target.outputs, "target outputs");
+    outputs = clonePortableJson(target.outputs);
+    recording = target.recording === void 0 ? void 0 : structuredClone(target.recording);
+    targetProviderAttempts = cloneOptionalPortableJson(target.providerAttempts, "target provider attempts");
+  } catch (error) {
+    if (error instanceof EvaluationGraphExecutionError) {
+      const errorMetrics = tryCloneExecutionMetrics(error.metrics, "target error metrics");
+      targetMetrics = errorMetrics ?? { ...targetMetrics, hasUnknownCost: true };
+      recording = error.recording === void 0 ? void 0 : structuredClone(error.recording);
+      targetProviderAttempts = tryCloneOptionalPortableJson(error.providerAttempts, "target error provider attempts");
+    } else {
+      targetMetrics = { ...targetMetrics, hasUnknownCost: true };
+    }
+    targetError = toErrorMessage(error);
+    targetMetrics = { ...targetMetrics, durationMs: Math.max(targetMetrics.durationMs, Date.now() - targetStartedAt) };
+    if (isAbort(error) || (signal == null ? void 0 : signal.aborted)) {
+      const executionStatus2 = "canceled";
+      const qualityStatus2 = "not-evaluated";
+      return {
+        id: makeId("trial"),
+        caseId: testCase.id,
+        caseName: testCase.name,
+        caseIndex,
+        trialIndex,
+        executionStatus: executionStatus2,
+        qualityStatus: qualityStatus2,
+        qualityReason: { code: "canceled", message: "The evaluation trial was canceled." },
+        inputs,
+        expected,
+        outputs,
+        observations: [],
+        targetMetrics,
+        evaluatorMetrics,
+        totalMetrics: { ...mergeMetrics(targetMetrics, evaluatorMetrics), hasUnknownCost: true },
+        error: targetError,
+        ...seed === void 0 ? {} : { seed },
+        ...recording === void 0 ? {} : { recording },
+        ...targetProviderAttempts === void 0 ? {} : { targetProviderAttempts }
+      };
+    }
+  }
+  const observations = [];
+  if (purpose === "evaluation" && targetError) {
+    observations.push({
+      id: "target-error",
+      kind: "assertion",
+      name: "Target graph",
+      required: true,
+      status: "error",
+      message: targetError
+    });
+  } else if (purpose === "evaluation" && evaluationMode === "pass-fail") {
+    for (const assertion of suite.assertions) {
+      try {
+        observations.push(evaluateAssertion(assertion, outputs, testCase));
+      } catch (error) {
+        observations.push({
+          id: assertion.id,
+          kind: "assertion",
+          name: assertion.name,
+          required: assertion.required !== false,
+          status: "error",
+          message: toErrorMessage(error)
+        });
+      }
+    }
+  }
+  for (const evaluator of purpose === "evaluation" ? suite.evaluators : []) {
+    if (targetError && (evaluationMode === "scoring" || !evaluator.runOnTargetError)) {
+      observations.push({
+        id: evaluator.id,
+        kind: "graph",
+        name: evaluator.name,
+        required: evaluator.required !== false,
+        status: "skipped",
+        message: "Skipped because the target graph failed."
+      });
+      continue;
+    }
+    const start = Date.now();
+    let completedAttemptMetrics;
+    let completedAttemptRecording;
+    let completedAttemptProviderAttempts;
+    try {
+      const result = await runWithTimeout(
+        (attemptSignal) => runGraph({
+          project,
+          graphId: evaluator.graphId,
+          inputs: createEvaluatorGraphInputs({
+            evaluator,
+            project,
+            testCase,
+            targetInputs: inputs,
+            expected,
+            targetOutputs: outputs,
+            run: { targetError: targetError ?? null, caseIndex, trialIndex, seed: seed ?? null }
+          }),
+          signal: attemptSignal,
+          metadata: { ...metadata, phase: "evaluator" }
+        }),
+        (_d = suite.configuration) == null ? void 0 : _d.timeoutMs,
+        signal
+      );
+      completedAttemptMetrics = cloneExecutionMetrics(result.metrics, `evaluator ${evaluator.name} metrics`);
+      completedAttemptRecording = result.recording === void 0 ? void 0 : structuredClone(result.recording);
+      completedAttemptProviderAttempts = cloneOptionalPortableJson(
+        result.providerAttempts,
+        `evaluator ${evaluator.name} provider attempts`
+      );
+      evaluatorMetrics = mergeMetrics(evaluatorMetrics, completedAttemptMetrics);
+      assertPortableJson(result.outputs, `evaluator ${evaluator.name} outputs`);
+      const observation = normalizeEvaluatorResult(result.outputs.result ?? null, evaluationMode);
+      observations.push({
+        ...observation,
+        id: evaluator.id,
+        name: evaluator.name,
+        required: evaluator.required !== false,
+        scoreWeight: evaluator.scoreWeight ?? 1,
+        durationMs: completedAttemptMetrics.durationMs || Date.now() - start,
+        ...completedAttemptMetrics.costUsd === void 0 ? {} : { costUsd: completedAttemptMetrics.costUsd },
+        ...completedAttemptProviderAttempts === void 0 ? {} : { providerAttempts: completedAttemptProviderAttempts },
+        ...completedAttemptRecording === void 0 ? {} : { recording: completedAttemptRecording }
+      });
+    } catch (error) {
+      const executionError = error instanceof EvaluationGraphExecutionError ? error : void 0;
+      const executionErrorMetrics = tryCloneExecutionMetrics(
+        executionError == null ? void 0 : executionError.metrics,
+        `evaluator ${evaluator.name} error metrics`
+      );
+      const failureMetrics = executionErrorMetrics ?? completedAttemptMetrics;
+      const failureProviderAttempts = tryCloneOptionalPortableJson(
+        executionError == null ? void 0 : executionError.providerAttempts,
+        `evaluator ${evaluator.name} error provider attempts`
+      ) ?? completedAttemptProviderAttempts;
+      const failureRecording = (executionError == null ? void 0 : executionError.recording) === void 0 ? completedAttemptRecording : structuredClone(executionError.recording);
+      if (executionErrorMetrics) {
+        evaluatorMetrics = mergeMetrics(evaluatorMetrics, executionErrorMetrics);
+      } else if (!completedAttemptMetrics) {
+        evaluatorMetrics = mergeMetrics(evaluatorMetrics, {
+          durationMs: Date.now() - start,
+          hasUnknownCost: true
+        });
+      }
+      if (isAbort(error) || (signal == null ? void 0 : signal.aborted)) {
+        const executionStatus2 = "canceled";
+        const qualityStatus2 = "not-evaluated";
+        return {
+          id: makeId("trial"),
+          caseId: testCase.id,
+          caseName: testCase.name,
+          caseIndex,
+          trialIndex,
+          executionStatus: executionStatus2,
+          qualityStatus: qualityStatus2,
+          qualityReason: { code: "canceled", message: "The evaluation trial was canceled." },
+          inputs,
+          expected,
+          outputs,
+          observations,
+          targetMetrics,
+          evaluatorMetrics,
+          totalMetrics: { ...mergeMetrics(targetMetrics, evaluatorMetrics), hasUnknownCost: true },
+          error: toErrorMessage(error),
+          ...seed === void 0 ? {} : { seed },
+          ...recording === void 0 ? {} : { recording },
+          ...targetProviderAttempts === void 0 ? {} : { targetProviderAttempts }
+        };
+      }
+      observations.push({
+        id: evaluator.id,
+        kind: "graph",
+        name: evaluator.name,
+        required: evaluator.required !== false,
+        status: "error",
+        message: toErrorMessage(error),
+        durationMs: (failureMetrics == null ? void 0 : failureMetrics.durationMs) ?? Date.now() - start,
+        ...(failureMetrics == null ? void 0 : failureMetrics.costUsd) === void 0 ? {} : { costUsd: failureMetrics.costUsd },
+        ...failureProviderAttempts === void 0 ? {} : { providerAttempts: failureProviderAttempts },
+        ...failureRecording === void 0 ? {} : { recording: failureRecording }
+      });
+    }
+  }
+  const required = observations.filter((entry) => entry.required);
+  const executionStatus = targetError === void 0 ? "completed" : "error";
+  let qualityStatus;
+  let qualityReason;
+  if (purpose === "execution-benchmark") {
+    qualityStatus = "not-evaluated";
+    qualityReason = {
+      code: "benchmark",
+      message: "This trial measured execution without evaluating output quality."
+    };
+  } else if (evaluationMode === "scoring") {
+    const scoringObservations = observations.filter((entry) => entry.kind === "graph");
+    const hasCompleteScore = targetError === void 0 && scoringObservations.length === suite.evaluators.length && scoringObservations.every((entry) => entry.status === "scored" && entry.score !== void 0);
+    if (hasCompleteScore) {
+      qualityStatus = "scored";
+      qualityReason = { code: "scores-complete", message: "All evaluator graphs returned a score for this trial." };
+    } else {
+      qualityStatus = "unable-to-evaluate";
+      qualityReason = {
+        code: "scores-incomplete",
+        message: targetError === void 0 ? "One or more evaluator graphs did not return a usable score for this trial." : "The target graph failed, so this trial could not contribute a score."
+      };
+    }
+  } else if (targetError !== void 0) {
+    qualityStatus = "failed";
+    qualityReason = {
+      code: "target-error",
+      message: "The target graph failed before it could produce a valid result."
+    };
+  } else if (required.some((entry) => entry.status === "failed")) {
+    qualityStatus = "failed";
+    qualityReason = { code: "checks-failed", message: "One or more required quality checks failed." };
+  } else if (required.some((entry) => entry.status === "error")) {
+    qualityStatus = "unable-to-evaluate";
+    qualityReason = {
+      code: "required-check-error",
+      message: "A required quality check could not be evaluated."
+    };
+  } else if (required.some((entry) => entry.status === "passed")) {
+    qualityStatus = "passed";
+    qualityReason = { code: "checks-passed", message: "All required per-trial quality checks passed." };
+  } else {
+    qualityStatus = "not-evaluated";
+    qualityReason = {
+      code: "no-trial-quality-checks",
+      message: "No required per-trial quality check evaluated this result."
+    };
+  }
+  const totalMetrics = mergeMetrics(targetMetrics, evaluatorMetrics);
+  return {
+    id: makeId("trial"),
+    caseId: testCase.id,
+    caseName: testCase.name,
+    caseIndex,
+    trialIndex,
+    executionStatus,
+    qualityStatus,
+    qualityReason,
+    inputs,
+    expected,
+    outputs,
+    observations,
+    targetMetrics,
+    evaluatorMetrics,
+    totalMetrics,
+    ...targetError === void 0 ? {} : { error: targetError },
+    ...seed === void 0 ? {} : { seed },
+    ...recording === void 0 ? {} : { recording },
+    ...targetProviderAttempts === void 0 ? {} : { targetProviderAttempts }
+  };
+}
+function percentile(values, percentage) {
+  if (values.length === 0) return 0;
+  const ordered = values.slice().sort((left, right) => left - right);
+  return ordered[Math.min(ordered.length - 1, Math.ceil(percentage / 100 * ordered.length) - 1)];
+}
+function meanObservationScore(observations) {
+  let weightedScore = 0;
+  let totalWeight = 0;
+  for (const observation of observations) {
+    if (observation.score === void 0) continue;
+    const weight = observation.scoreWeight ?? 1;
+    weightedScore += observation.score * weight;
+    totalWeight += weight;
+  }
+  return totalWeight === 0 ? void 0 : weightedScore / totalWeight;
+}
+function meanObservationMetrics(observations) {
+  const totals = {};
+  const counts = {};
+  for (const observation of observations) {
+    for (const [name, value] of Object.entries(observation.metrics ?? {})) {
+      totals[name] = (totals[name] ?? 0) + value;
+      counts[name] = (counts[name] ?? 0) + 1;
+    }
+  }
+  return Object.fromEntries(Object.entries(totals).map(([name, total]) => [name, total / counts[name]]));
+}
+function aggregate(trials, evaluationMode = "pass-fail") {
+  const incurred = trials;
+  const settled = trials.filter((trial) => trial.executionStatus !== "canceled");
+  const completed = trials.filter((trial) => trial.executionStatus === "completed");
+  const evaluated = completed.filter((trial) => trial.qualityStatus === "passed" || trial.qualityStatus === "failed");
+  const passed = evaluated.filter((trial) => trial.qualityStatus === "passed");
+  const failed = evaluated.filter((trial) => trial.qualityStatus === "failed");
+  const notEvaluated = completed.filter((trial) => trial.qualityStatus === "not-evaluated");
+  const unable = completed.filter((trial) => trial.qualityStatus === "unable-to-evaluate");
+  const errors = trials.filter((trial) => trial.executionStatus === "error");
+  const canceled = trials.filter((trial) => trial.executionStatus === "canceled");
+  const settledObservations = settled.flatMap((trial) => trial.observations);
+  const meanScore = meanObservationScore(settledObservations);
+  const accountingComplete = !incurred.some((trial) => trial.totalMetrics.hasUnknownCost);
+  const totalCostUsd = accountingComplete ? incurred.reduce((sum, trial) => sum + (trial.totalMetrics.costUsd ?? 0), 0) : void 0;
+  const meanMetrics = meanObservationMetrics(settledObservations);
+  const byCase = /* @__PURE__ */ new Map();
+  for (const trial of trials) byCase.set(trial.caseId, [...byCase.get(trial.caseId) ?? [], trial]);
+  const cases = Array.from(byCase.values()).map((caseTrials) => {
+    const caseSettled = caseTrials.filter((trial) => trial.executionStatus !== "canceled");
+    const caseCompleted = caseSettled.filter((trial) => trial.executionStatus === "completed");
+    const caseEvaluated = caseCompleted.filter(
+      (trial) => trial.qualityStatus === "passed" || trial.qualityStatus === "failed"
+    );
+    const casePassed = caseEvaluated.filter((trial) => trial.qualityStatus === "passed");
+    const caseFailed = caseEvaluated.filter((trial) => trial.qualityStatus === "failed");
+    const caseScored = caseCompleted.filter((trial) => trial.qualityStatus === "scored");
+    const caseObservations = caseSettled.flatMap((trial) => trial.observations);
+    const caseTrialScores = caseScored.map((trial) => meanObservationScore(trial.observations)).filter((score) => score !== void 0);
+    const caseMeanScore = evaluationMode === "scoring" ? caseTrialScores.length === 0 ? void 0 : caseTrialScores.reduce((sum, score) => sum + score, 0) / caseTrialScores.length : meanObservationScore(caseObservations);
+    return {
+      caseId: caseTrials[0].caseId,
+      caseName: caseTrials[0].caseName,
+      ...caseEvaluated.length === 0 ? {} : { passRate: casePassed.length / caseEvaluated.length },
+      evaluatedTrialCount: caseEvaluated.length,
+      passedTrialCount: casePassed.length,
+      failedTrialCount: caseFailed.length,
+      notEvaluatedTrialCount: caseCompleted.filter((trial) => trial.qualityStatus === "not-evaluated").length,
+      unableToEvaluateTrialCount: caseCompleted.filter((trial) => trial.qualityStatus === "unable-to-evaluate").length,
+      erroredTrialCount: caseTrials.filter((trial) => trial.executionStatus === "error").length,
+      canceledTrialCount: caseTrials.filter((trial) => trial.executionStatus === "canceled").length,
+      ...evaluationMode === "scoring" ? {
+        scoredTrialCount: caseScored.length,
+        missingScoreTrialCount: caseTrials.length - caseScored.length
+      } : {},
+      ...caseMeanScore === void 0 ? {} : { meanScore: caseMeanScore },
+      metrics: meanObservationMetrics(caseObservations)
+    };
+  });
+  const scoredTrialCount = cases.reduce((sum, testCase) => sum + (testCase.scoredTrialCount ?? 0), 0);
+  const scoringCaseMeans = cases.map((testCase) => testCase.meanScore).filter((score) => score !== void 0);
+  const scoringMeanScore = scoringCaseMeans.length === 0 ? void 0 : scoringCaseMeans.reduce((sum, score) => sum + score, 0) / scoringCaseMeans.length;
+  const aggregateValue = {
+    trialCount: trials.length,
+    evaluatedTrialCount: evaluated.length,
+    notEvaluatedTrialCount: notEvaluated.length,
+    unableToEvaluateTrialCount: unable.length,
+    passedTrialCount: passed.length,
+    failedTrialCount: failed.length,
+    erroredTrialCount: errors.length,
+    canceledTrialCount: canceled.length,
+    passRate: evaluated.length === 0 ? 0 : passed.length / evaluated.length,
+    ...evaluationMode === "scoring" ? {
+      scoredTrialCount,
+      missingScoreTrialCount: trials.length - scoredTrialCount,
+      ...scoringMeanScore === void 0 ? {} : { meanScore: scoringMeanScore }
+    } : meanScore === void 0 ? {} : { meanScore },
+    averageLatencyMs: incurred.length === 0 ? 0 : incurred.reduce((sum, trial) => sum + trial.totalMetrics.durationMs, 0) / incurred.length,
+    p95LatencyMs: percentile(
+      incurred.map((trial) => trial.totalMetrics.durationMs),
+      95
+    ),
+    ...incurred.length === 0 || totalCostUsd === void 0 ? {} : { totalCostUsd, averageCostUsd: totalCostUsd / incurred.length },
+    targetErrorRate: settled.length === 0 ? 0 : errors.length / settled.length,
+    evaluatorErrorRate: settled.length === 0 ? 0 : settled.filter(
+      (trial) => trial.observations.some((observation) => observation.kind === "graph" && observation.status === "error")
+    ).length / settled.length,
+    toolFailureRate: settled.reduce((sum, trial) => sum + (trial.totalMetrics.toolCallCount ?? 0), 0) === 0 ? 0 : settled.reduce((sum, trial) => sum + (trial.totalMetrics.toolFailureCount ?? 0), 0) / settled.reduce((sum, trial) => sum + (trial.totalMetrics.toolCallCount ?? 0), 0),
+    metrics: meanMetrics
+  };
+  return {
+    aggregate: aggregateValue,
+    cases
+  };
+}
+function thresholdValue(aggregateValue, metric) {
+  switch (metric) {
+    case "pass-rate":
+      return aggregateValue.evaluatedTrialCount === 0 ? void 0 : aggregateValue.passRate;
+    case "mean-score":
+      return aggregateValue.meanScore;
+    case "target-error-rate":
+      return aggregateValue.targetErrorRate;
+    case "evaluator-error-rate":
+      return aggregateValue.evaluatorErrorRate;
+    case "tool-failure-rate":
+      return aggregateValue.toolFailureRate;
+    case "average-cost":
+      return aggregateValue.averageCostUsd;
+    case "total-cost":
+      return aggregateValue.totalCostUsd;
+    case "average-latency-ms":
+      return aggregateValue.averageLatencyMs;
+    case "p95-latency-ms":
+      return aggregateValue.p95LatencyMs;
+    default:
+      return metric.startsWith("custom:") ? aggregateValue.metrics[metric.slice("custom:".length)] : void 0;
+  }
+}
+function isHigherBetterMetric(metric) {
+  return metric === "pass-rate" || metric === "mean-score" || metric.startsWith("custom:");
+}
+function baselineCompatible(current, baseline) {
+  return current.executionMode === baseline.provenance.executionMode && current.suiteFingerprint === baseline.provenance.suiteFingerprint && current.datasetFingerprint === baseline.provenance.datasetFingerprint && current.targetFingerprint === baseline.provenance.targetFingerprint && canonicalStringify(current.evaluatorFingerprints) === canonicalStringify(baseline.provenance.evaluatorFingerprints);
+}
+function executionNodeConfiguration(node) {
+  return {
+    id: node.id,
+    type: node.type,
+    title: node.title,
+    data: node.data,
+    variants: node.variants,
+    isSplitRun: node.isSplitRun,
+    isSplitSequential: node.isSplitSequential,
+    splitRunMax: node.splitRunMax,
+    splitRunConcurrency: node.splitRunConcurrency,
+    disabled: node.disabled,
+    isConditional: node.isConditional
+  };
+}
+function executionConnectionConfiguration(connection) {
+  return {
+    outputNodeId: connection.outputNodeId,
+    inputNodeId: connection.inputNodeId,
+    outputId: connection.outputId,
+    inputId: connection.inputId
+  };
+}
+function executionGraphConfiguration(graph) {
+  var _a, _b, _c;
+  return {
+    metadata: {
+      id: (_a = graph.metadata) == null ? void 0 : _a.id,
+      name: (_b = graph.metadata) == null ? void 0 : _b.name,
+      attachedData: (_c = graph.metadata) == null ? void 0 : _c.attachedData
+    },
+    nodes: graph.nodes.map(executionNodeConfiguration),
+    connections: graph.connections.map(executionConnectionConfiguration)
+  };
+}
+function executionProjectGraphs(project) {
+  return Object.fromEntries(
+    Object.entries(project.graphs).map(([graphId, graph]) => [graphId, executionGraphConfiguration(graph)])
+  );
+}
+function executionProjectConfiguration(project) {
+  return {
+    ...project.plugins === void 0 ? {} : { plugins: project.plugins },
+    ...project.nodePrefabs === void 0 ? {} : {
+      nodePrefabs: Object.fromEntries(
+        Object.entries(project.nodePrefabs).map(([prefabId, prefab]) => [
+          prefabId,
+          { id: prefab.id, sourceNode: executionNodeConfiguration(prefab.sourceNode) }
+        ])
+      )
+    },
+    ...project.data === void 0 ? {} : { data: project.data },
+    ...project.references === void 0 ? {} : { references: project.references },
+    ...project.metadata.mcpServer === void 0 ? {} : { mcpServer: project.metadata.mcpServer },
+    ...project.metadata.knowledgeStores === void 0 ? {} : { knowledgeStores: project.metadata.knowledgeStores }
+  };
+}
+function canonicalizeExecutionFingerprintValue(value, path = "$", stack = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${path} must not contain a non-finite number.`);
+    return value;
+  }
+  if (value === void 0) return null;
+  if (typeof value !== "object") throw new Error(`${path} must be JSON-compatible to fingerprint an evaluation.`);
+  if (stack.has(value)) throw new Error(`${path} must not contain a cycle.`);
+  if (Array.isArray(value)) {
+    stack.add(value);
+    const normalized2 = Array.from(
+      value,
+      (entry, index) => canonicalizeExecutionFingerprintValue(entry, `${path}[${index}]`, stack)
+    );
+    stack.delete(value);
+    return normalized2;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new Error(`${path} must be a plain object to fingerprint an evaluation.`);
+  }
+  stack.add(value);
+  const normalized = Object.fromEntries(
+    Object.entries(value).flatMap(
+      ([key, entry]) => entry === void 0 ? [] : [[key, canonicalizeExecutionFingerprintValue(entry, `${path}.${key}`, stack)]]
+    )
+  );
+  stack.delete(value);
+  return normalized;
+}
+function fingerprintExecutionProject(value) {
+  return fingerprint(canonicalizeExecutionFingerprintValue(value));
+}
+function fingerprintGraphDependency(project, graphId) {
+  const visited = /* @__PURE__ */ new Set();
+  const graphEntries = Object.entries(project.graphs);
+  const asKnownGraphId = (value) => {
+    return typeof value === "string" && project.graphs[value] ? value : void 0;
+  };
+  const getStaticChildren = (graph) => {
+    const children = /* @__PURE__ */ new Set();
+    const autoDelegatedToolNames = [];
+    const add = (value) => {
+      const id = asKnownGraphId(value);
+      if (id) children.add(id);
+    };
+    for (const node of graph.nodes) {
+      const data = node.data;
+      switch (node.type) {
+        case "subGraph":
+        case "loopUntil":
+        case "cron":
+          add(node.type === "subGraph" ? data.graphId : data.targetGraph);
+          break;
+        case "delegateFunctionCall": {
+          add(data.unknownHandler);
+          if (data.autoDelegate === true) {
+            continue;
+          }
+          if (Array.isArray(data.handlers)) {
+            for (const handler of data.handlers) {
+              if (handler && typeof handler === "object" && "value" in handler) {
+                add(handler.value);
+              }
+            }
+          }
+          break;
+        }
+        case "gptFunction":
+          if (data.useNameInput !== true && typeof data.name === "string" && data.name) {
+            autoDelegatedToolNames.push(data.name);
+          }
+          break;
+      }
+    }
+    if (graph.nodes.some(
+      (node) => node.type === "delegateFunctionCall" && node.data.autoDelegate === true
+    )) {
+      for (const toolName of autoDelegatedToolNames) {
+        const resolved = (0, import_rivet2_core.findAutoDelegateGraphCandidate)(
+          graphEntries,
+          toolName,
+          ([, candidate]) => {
+            var _a;
+            return (_a = candidate.metadata) == null ? void 0 : _a.name;
+          }
+        );
+        if (resolved) children.add(resolved[0]);
+      }
+    }
+    return [...children];
+  };
+  const collect = (id) => {
+    if (visited.has(id)) return { graphId: id, cycle: true };
+    visited.add(id);
+    const graph = project.graphs[id];
+    if (!graph) return { graphId: id, missing: true };
+    const dependencies = getStaticChildren(graph).map(collect);
+    return { graph: executionGraphConfiguration(graph), dependencies };
+  };
+  return fingerprintExecutionProject({
+    graphDependency: collect(graphId),
+    projectExecutionConfiguration: executionProjectConfiguration(project)
+  });
+}
+function unavailableThresholdResult(threshold, message) {
+  return {
+    id: threshold.id,
+    metric: threshold.metric,
+    operator: threshold.operator,
+    status: "unavailable",
+    expectedValue: threshold.value,
+    message
+  };
+}
+function evaluateThresholdResults(aggregateValue, thresholds = [], baseline) {
+  return thresholds.map((threshold) => {
+    const actual = thresholdValue(aggregateValue, threshold.metric);
+    if (actual === void 0 || !Number.isFinite(actual)) {
+      const message = threshold.metric === "average-cost" || threshold.metric === "total-cost" ? "Some provider pricing was unavailable, so this cost requirement could not be evaluated." : threshold.metric === "pass-rate" ? "No completed trial produced an evaluated pass or fail result." : `The metric "${threshold.metric}" was unavailable.`;
+      return unavailableThresholdResult(threshold, message);
+    }
+    if (threshold.operator === "max-regression") {
+      const isCostMetric = threshold.metric === "average-cost" || threshold.metric === "total-cost";
+      if (isCostMetric && ((baseline == null ? void 0 : baseline.accountingStatus) === "partial" || (baseline == null ? void 0 : baseline.provenance.accountingComplete) === false)) {
+        return unavailableThresholdResult(
+          threshold,
+          "The baseline has partial accounting because some provider pricing was unavailable, so this cost regression could not be evaluated."
+        );
+      }
+      const previous = baseline ? thresholdValue(baseline.aggregate, threshold.metric) : void 0;
+      if (previous === void 0 || !Number.isFinite(previous)) {
+        return unavailableThresholdResult(
+          threshold,
+          baseline ? `The baseline does not contain a comparable "${threshold.metric}" metric.` : "A compatible baseline is required for this regression requirement."
+        );
+      }
+      const delta = isHigherBetterMetric(threshold.metric) ? previous - actual : actual - previous;
+      const zeroBaselineRegression = previous === 0 && delta > 0;
+      const regression = previous === 0 ? 0 : delta / Math.abs(previous);
+      const failed = zeroBaselineRegression || regression > threshold.value;
+      return {
+        id: threshold.id,
+        metric: threshold.metric,
+        operator: threshold.operator,
+        status: failed ? "failed" : "passed",
+        expectedValue: threshold.value,
+        actualValue: actual,
+        baselineValue: previous,
+        ...zeroBaselineRegression ? {} : { regression },
+        message: failed ? `Regression exceeded the allowed ${formatThresholdResultValue(
+          threshold.metric,
+          threshold.operator,
+          threshold.value
+        )}.` : `Regression stayed within the allowed ${formatThresholdResultValue(
+          threshold.metric,
+          threshold.operator,
+          threshold.value
+        )}.`
+      };
+    }
+    const passed = threshold.operator === "at-least" ? actual >= threshold.value : actual <= threshold.value;
+    return {
+      id: threshold.id,
+      metric: threshold.metric,
+      operator: threshold.operator,
+      status: passed ? "passed" : "failed",
+      expectedValue: threshold.value,
+      actualValue: actual,
+      message: passed ? `Actual value ${formatThresholdResultValue(threshold.metric, threshold.operator, actual)} satisfied ${threshold.operator} ${formatThresholdResultValue(threshold.metric, threshold.operator, threshold.value)}.` : `Actual value ${formatThresholdResultValue(threshold.metric, threshold.operator, actual)} did not satisfy ${threshold.operator} ${formatThresholdResultValue(threshold.metric, threshold.operator, threshold.value)}.`
+    };
+  });
+}
+function createProvenance(project, suite, dataset, options) {
+  const purpose = options.purpose ?? "evaluation";
+  const evaluationMode = getEvaluationSuiteMode(suite);
+  const configuration = suite.configuration;
+  const materialEvaluators = suite.evaluators.map((evaluator) => {
+    var _a;
+    return {
+      graphId: evaluator.graphId,
+      inputBindings: ((_a = evaluator.inputBindings) == null ? void 0 : _a.slice().sort((left, right) => left.graphInputId.localeCompare(right.graphInputId))) ?? null,
+      // Normalize defaults so editing a control between its implicit and
+      // explicit default does not invalidate a baseline.
+      scoreWeight: evaluator.scoreWeight ?? 1,
+      ...evaluationMode === "scoring" ? {} : { required: evaluator.required !== false, runOnTargetError: evaluator.runOnTargetError === true }
+    };
+  });
+  const materialSuiteDefinition = {
+    purpose,
+    evaluationMode,
+    targetGraphId: suite.targetGraphId,
+    datasetId: suite.datasetId,
+    inputBindings: suite.inputBindings.slice().sort((left, right) => left.graphInputId.localeCompare(right.graphInputId)),
+    configuration: {
+      trialCount: (configuration == null ? void 0 : configuration.trialCount) ?? 1,
+      concurrency: (configuration == null ? void 0 : configuration.concurrency) ?? DEFAULT_CONCURRENCY,
+      timeoutMs: (configuration == null ? void 0 : configuration.timeoutMs) ?? null,
+      seed: (configuration == null ? void 0 : configuration.seed) ?? null,
+      seedGraphInputId: (configuration == null ? void 0 : configuration.seedGraphInputId) ?? null
+    },
+    ...purpose !== "evaluation" ? {} : evaluationMode === "scoring" ? { evaluators: materialEvaluators } : {
+      assertions: suite.assertions,
+      evaluators: materialEvaluators,
+      thresholds: suite.thresholds ?? []
+    }
+  };
+  return {
+    projectFingerprint: options.projectFingerprint ?? fingerprintExecutionProject({
+      projectId: project.metadata.id,
+      graphs: executionProjectGraphs(project),
+      executionConfiguration: executionProjectConfiguration(project)
+    }),
+    // Names, descriptions, tags, and recording-retention choices do not
+    // change an execution result. Quality-only definitions likewise cannot
+    // stale an execution-benchmark comparison because they never ran. Pass/
+    // fail assertions and thresholds are equally dormant in scoring mode.
+    suiteFingerprint: fingerprint(materialSuiteDefinition),
+    datasetFingerprint: fingerprintEvaluationDataset(dataset),
+    targetFingerprint: fingerprintGraphDependency(project, suite.targetGraphId),
+    evaluatorFingerprints: purpose === "evaluation" ? Object.fromEntries(
+      suite.evaluators.map((evaluator) => [evaluator.id, fingerprintGraphDependency(project, evaluator.graphId)])
+    ) : {},
+    executionMode: options.executionMode ?? "unknown",
+    accountingComplete: true
+  };
+}
+async function runEvaluationSuite(options) {
+  var _a, _b, _c, _d, _e;
+  const suite = resolveSuite(options.evaluationData, options.suiteId);
+  const purpose = options.purpose ?? "evaluation";
+  const evaluationMode = getEvaluationSuiteMode(suite);
+  if (purpose === "evaluation" && !hasAuthoritativeEvaluationCriteria(suite)) {
+    throw new Error(
+      evaluationMode === "scoring" ? `Scoring evaluation suite "${suite.name}" has no evaluator graph. Add an evaluator that returns result.score or run an execution benchmark.` : `Evaluation suite "${suite.name}" has no required quality check or threshold. Add a quality criterion or run it as an execution benchmark.`
+    );
+  }
+  validateSuite(options.project, suite, options.dataset, purpose);
+  const runId = options.runId ?? makeId("evaluation");
+  const run = {
+    version: 2,
+    id: runId,
+    projectId: options.project.metadata.id,
+    suiteId: suite.id,
+    suiteName: suite.name,
+    revision: 0,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    purpose,
+    evaluationMode,
+    executionStatus: "running",
+    qualityStatus: "not-evaluated",
+    qualityReason: { code: "in-progress", message: "The run is still in progress." },
+    accountingStatus: "complete",
+    provenance: createProvenance(options.project, suite, options.dataset, options),
+    trials: [],
+    thresholdResults: [],
+    warnings: []
+  };
+  const trialCount = Math.max(1, Math.floor(((_a = suite.configuration) == null ? void 0 : _a.trialCount) ?? 1));
+  const concurrency = Math.min(
+    MAX_CONCURRENCY,
+    Math.max(1, Math.floor(((_b = suite.configuration) == null ? void 0 : _b.concurrency) ?? DEFAULT_CONCURRENCY))
+  );
+  const work = options.dataset.cases.filter((testCase) => testCase.enabled !== false).flatMap(
+    (testCase, caseIndex) => Array.from({ length: trialCount }, (_, trialIndex) => ({ testCase, caseIndex, trialIndex }))
+  );
+  const publish = () => {
+    var _a2;
+    run.revision = (run.revision ?? 0) + 1;
+    (_a2 = options.onUpdate) == null ? void 0 : _a2.call(options, structuredClone(run));
+  };
+  publish();
+  const workPool = runEvaluationWorkPool({
+    work,
+    concurrency,
+    signal: options.signal,
+    execute: async (task) => {
+      try {
+        return await runTrial({
+          ...task,
+          project: options.project,
+          suite,
+          dataset: options.dataset,
+          purpose,
+          runId,
+          runGraph: options.runGraph,
+          signal: options.signal
+        });
+      } catch (error) {
+        const executionStatus = isAbort(error) ? "canceled" : "error";
+        const qualityStatus = purpose === "evaluation" && executionStatus === "error" ? evaluationMode === "scoring" ? "unable-to-evaluate" : "failed" : "not-evaluated";
+        return {
+          id: makeId("trial"),
+          caseId: task.testCase.id,
+          caseName: task.testCase.name,
+          caseIndex: task.caseIndex,
+          trialIndex: task.trialIndex,
+          executionStatus,
+          qualityStatus,
+          qualityReason: executionStatus === "canceled" ? { code: "canceled", message: "The evaluation trial was canceled." } : purpose === "evaluation" ? evaluationMode === "scoring" ? { code: "scores-incomplete", message: "The target graph could not produce a score." } : { code: "target-error", message: "The target graph could not be executed." } : { code: "benchmark", message: "This benchmark trial could not be executed." },
+          inputs: {},
+          expected: {},
+          outputs: {},
+          observations: [],
+          targetMetrics: createEmptyMetrics(),
+          evaluatorMetrics: createEmptyMetrics(),
+          totalMetrics: executionStatus === "canceled" ? { ...createEmptyMetrics(), hasUnknownCost: true } : createEmptyMetrics(),
+          error: toErrorMessage(error)
+        };
+      }
+    },
+    onSettled: (_result, _index, currentResults) => {
+      run.trials = currentResults.filter((result) => result !== void 0);
+      publish();
+    }
+  });
+  const results = await workPool;
+  run.trials = results.filter((result) => result !== void 0);
+  run.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const outcome = aggregate(run.trials, evaluationMode);
+  run.aggregate = outcome.aggregate;
+  run.provenance.accountingComplete = !run.trials.some((trial) => trial.totalMetrics.hasUnknownCost);
+  run.accountingStatus = run.provenance.accountingComplete ? "complete" : "partial";
+  if (run.accountingStatus === "partial") {
+    run.warnings.push(
+      "Some provider pricing was unavailable. Cost totals are unavailable, and cost requirements cannot be evaluated."
+    );
+  }
+  if ((_c = options.signal) == null ? void 0 : _c.aborted) {
+    run.executionStatus = "canceled";
+    run.qualityStatus = "not-evaluated";
+    run.qualityReason = { code: "canceled", message: "The evaluation run was canceled." };
+  } else if (purpose === "execution-benchmark") {
+    run.executionStatus = "completed";
+    run.qualityStatus = "not-evaluated";
+    run.qualityReason = {
+      code: "benchmark",
+      message: "This run measured execution without evaluating output quality."
+    };
+  } else if (evaluationMode === "scoring") {
+    run.executionStatus = "completed";
+    if ((outcome.aggregate.missingScoreTrialCount ?? run.trials.length) > 0) {
+      run.qualityStatus = "unable-to-evaluate";
+      run.qualityReason = {
+        code: "scores-incomplete",
+        message: "One or more requested trials did not produce a usable score. Available averages are shown with coverage."
+      };
+      run.warnings.push(
+        `Score coverage is ${outcome.aggregate.scoredTrialCount ?? 0} of ${outcome.aggregate.trialCount} requested trials.`
+      );
+    } else if ((outcome.aggregate.scoredTrialCount ?? 0) > 0) {
+      run.qualityStatus = "scored";
+      run.qualityReason = {
+        code: "scores-complete",
+        message: "Every requested trial produced a score. Overall score is the equal-weight average of case averages."
+      };
+    } else {
+      run.qualityStatus = "unable-to-evaluate";
+      run.qualityReason = { code: "scores-incomplete", message: "No requested trial produced a usable score." };
+    }
+  } else {
+    const baseline = options.baseline ?? options.evaluationData.baselines.find((candidate) => candidate.suiteId === suite.id);
+    const usableBaseline = baseline && baselineCompatible(run.provenance, baseline) ? baseline : void 0;
+    if (baseline && !usableBaseline)
+      run.warnings.push(
+        "The suite baseline is stale because its target, dataset, bindings, or evaluator definition changed."
+      );
+    run.thresholdResults = evaluateThresholdResults(outcome.aggregate, suite.thresholds, usableBaseline);
+    const hasPassRateThreshold = ((_d = suite.thresholds) == null ? void 0 : _d.some((threshold) => threshold.metric === "pass-rate")) ?? false;
+    const hasTargetErrorRateThreshold = ((_e = suite.thresholds) == null ? void 0 : _e.some((threshold) => threshold.metric === "target-error-rate")) ?? false;
+    const hasUngovernedCheckFailure = !hasPassRateThreshold && run.trials.some((trial) => trial.executionStatus === "completed" && trial.qualityStatus === "failed");
+    const hasUngovernedTargetError = !hasTargetErrorRateThreshold && run.trials.some((trial) => trial.executionStatus === "error");
+    const hasThresholdFailure = run.thresholdResults.some((result) => result.status === "failed");
+    const hasUnavailableEvidence = run.trials.some((trial) => trial.qualityStatus === "unable-to-evaluate") || run.thresholdResults.some((result) => result.status === "unavailable");
+    const hasAuthoritativePass = run.trials.some((trial) => trial.executionStatus === "completed" && trial.qualityStatus === "passed") || run.thresholdResults.some((result) => result.status === "passed");
+    if (hasUngovernedCheckFailure || hasUngovernedTargetError || hasThresholdFailure) {
+      run.qualityStatus = "failed";
+      run.qualityReason = {
+        code: hasThresholdFailure ? "thresholds-failed" : "checks-failed",
+        message: hasThresholdFailure ? "One or more required aggregate thresholds failed." : "One or more target executions or required quality checks failed."
+      };
+    } else if (hasUnavailableEvidence) {
+      run.qualityStatus = "unable-to-evaluate";
+      run.qualityReason = {
+        code: run.thresholdResults.some((result) => result.status === "unavailable") ? "required-metric-unavailable" : "required-check-error",
+        message: run.thresholdResults.some((result) => result.status === "unavailable") ? "A required aggregate metric could not be evaluated." : "A required quality check could not be evaluated."
+      };
+    } else if (hasAuthoritativePass) {
+      run.qualityStatus = "passed";
+      run.qualityReason = {
+        code: run.thresholdResults.length > 0 ? "thresholds-passed" : "checks-passed",
+        message: run.thresholdResults.length > 0 ? "All required quality checks and aggregate thresholds passed." : "All required quality checks passed."
+      };
+    } else {
+      run.qualityStatus = "not-evaluated";
+      run.qualityReason = {
+        code: "no-completed-trials",
+        message: "No completed trial produced an authoritative quality result."
+      };
+    }
+    run.executionStatus = "completed";
+  }
+  publish();
+  return run;
+}
+async function runEvaluationCases(options) {
+  const permitted = new Set(options.caseIds);
+  return runEvaluationSuite({
+    ...options,
+    dataset: { ...options.dataset, cases: options.dataset.cases.filter((testCase) => permitted.has(testCase.id)) }
+  });
+}
+function summarizeEvaluationRun(run) {
+  return run.aggregate ? aggregate(run.trials, getEvaluationSuiteMode(run)) : void 0;
+}
+function createEvaluationBaselineSnapshot(run) {
+  const normalizedRun = normalizeEvaluationRun(run);
+  if (normalizedRun.executionStatus !== "completed") {
+    throw new Error("Only a completed evaluation run can be promoted to a baseline.");
+  }
+  if (normalizedRun.purpose !== "execution-benchmark" && getEvaluationSuiteMode(normalizedRun) === "scoring" && normalizedRun.qualityStatus !== "scored") {
+    throw new Error("A scoring baseline needs a complete score for every requested trial.");
+  }
+  const summary = summarizeEvaluationRun(normalizedRun);
+  if (!summary) throw new Error("Only a completed evaluation run can be promoted to a baseline.");
+  return {
+    id: makeId("baseline"),
+    suiteId: normalizedRun.suiteId,
+    sourceRunId: normalizedRun.id,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    provenance: normalizedRun.provenance,
+    aggregate: summary.aggregate,
+    purpose: normalizedRun.purpose,
+    evaluationMode: getEvaluationSuiteMode(normalizedRun),
+    qualityStatus: normalizedRun.qualityStatus,
+    qualityReason: normalizedRun.qualityReason,
+    accountingStatus: normalizedRun.accountingStatus,
+    cases: summary.cases
+  };
+}
+
+// src/store.ts
+var InMemoryEvaluationRunStore = class {
+  #runs = /* @__PURE__ */ new Map();
+  #datasetSnapshots = /* @__PURE__ */ new Map();
+  #recordings = /* @__PURE__ */ new Map();
+  async put(run) {
+    const normalized = normalizeEvaluationRun(run);
+    const key = `${normalized.projectId}/${normalized.id}`;
+    const existing = this.#runs.get(key);
+    if (!shouldReplaceEvaluationRun(existing, normalized)) return;
+    this.#runs.set(key, structuredClone(normalized));
+  }
+  async get(input) {
+    const run = this.#runs.get(`${input.projectId}/${input.runId}`);
+    return run ? normalizeEvaluationRun(run) : void 0;
+  }
+  async list(input) {
+    return Array.from(this.#runs.values()).filter(
+      (run) => run.projectId === input.projectId && (input.suiteId === void 0 || run.suiteId === input.suiteId)
+    ).sort((left, right) => right.startedAt.localeCompare(left.startedAt)).map(normalizeEvaluationRun);
+  }
+  async delete(input) {
+    this.#runs.delete(`${input.projectId}/${input.runId}`);
+    for (const [key, artifact] of this.#recordings) {
+      if (artifact.projectId === input.projectId && artifact.runId === input.runId) this.#recordings.delete(key);
+    }
+  }
+  async putDatasetSnapshot(snapshot) {
+    assertEvaluationDatasetSnapshot(snapshot);
+    const key = `${snapshot.projectId}/${snapshot.fingerprint}`;
+    if (this.#datasetSnapshots.has(key)) return;
+    this.#datasetSnapshots.set(key, structuredClone(snapshot));
+  }
+  async getDatasetSnapshot(input) {
+    const snapshot = this.#datasetSnapshots.get(`${input.projectId}/${input.fingerprint}`);
+    return snapshot ? structuredClone(snapshot) : void 0;
+  }
+  async putRecording(artifact) {
+    const key = `${artifact.projectId}/${artifact.reference.id}`;
+    const existing = this.#recordings.get(key);
+    if (existing && (existing.runId !== artifact.runId || existing.trialId !== artifact.trialId)) {
+      throw new Error("An evaluation recording ID cannot be reassigned to another run or trial.");
+    }
+    const next = structuredClone(artifact);
+    if (existing) next.reference = structuredClone(existing.reference);
+    this.#recordings.set(key, next);
+  }
+  async getRecording(input) {
+    const artifact = this.#recordings.get(`${input.projectId}/${input.recordingId}`);
+    if (!artifact) return void 0;
+    if (artifact.reference.retention === "temporary" && artifact.reference.expiresAt && Date.parse(artifact.reference.expiresAt) <= Date.now()) {
+      this.#recordings.delete(`${input.projectId}/${input.recordingId}`);
+      return void 0;
+    }
+    return structuredClone(artifact);
+  }
+  async updateRecordingRetention(input) {
+    const key = `${input.projectId}/${input.recordingId}`;
+    const artifact = this.#recordings.get(key);
+    if (!artifact) return;
+    artifact.reference = {
+      id: artifact.reference.id,
+      retention: input.retention,
+      ...input.expiresAt === void 0 ? {} : { expiresAt: input.expiresAt }
+    };
+  }
+  async promoteBaseline(input) {
+    for (const artifact of this.#recordings.values()) {
+      if (artifact.projectId !== input.projectId || artifact.runId !== input.runId) continue;
+      artifact.reference = { id: artifact.reference.id, retention: "baseline" };
+    }
+  }
+};
+
+// src/serialization.ts
+var yaml = __toESM(require("yaml"), 1);
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireRecord(value, path) {
+  if (!isRecord2(value)) throw new Error(`${path} must be an object.`);
+  return value;
+}
+function requireString(value, path) {
+  if (typeof value !== "string" || value.trim().length === 0) throw new Error(`${path} must be a non-empty string.`);
+}
+function requireText(value, path) {
+  if (typeof value !== "string") throw new Error(`${path} must be a string.`);
+}
+function requireBoolean(value, path) {
+  if (typeof value !== "boolean") throw new Error(`${path} must be a boolean.`);
+}
+function requireFiniteNumber(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${path} must be a finite number.`);
+}
+function requireArray(value, path) {
+  if (!Array.isArray(value)) throw new Error(`${path} must be an array.`);
+  return value;
+}
+function stripLegacyEditorSelections(data) {
+  const { selectedSuiteId: _selectedSuiteId, selectedDatasetId: _selectedDatasetId, ...projectData } = data;
+  return projectData;
+}
+function validateOptionalPrimitive(record, key, type, path) {
+  const value = record[key];
+  if (value === void 0) return;
+  if (type === "number") requireFiniteNumber(value, `${path}.${key}`);
+  else if (typeof value !== type) throw new Error(`${path}.${key} must be a ${type}.`);
+}
+var ASSERTION_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not-equals",
+  "contains",
+  "matches-regex",
+  "type-is",
+  "json-schema",
+  "number-at-least",
+  "number-at-most",
+  "number-between",
+  "array-includes",
+  "set-overlaps",
+  "contains-any",
+  "contains-all"
+]);
+var EVALUATOR_CONTEXT_INPUTS = /* @__PURE__ */ new Set(["case", "inputs", "expected", "outputs", "run"]);
+function validateSuiteShape(value, index) {
+  const path = `evaluations.suites[${index}]`;
+  const suite = requireRecord(value, path);
+  for (const key of ["id", "targetGraphId", "datasetId"]) requireString(suite[key], `${path}.${key}`);
+  requireText(suite.name, `${path}.name`);
+  if (suite.evaluationMode !== void 0 && suite.evaluationMode !== "pass-fail" && suite.evaluationMode !== "scoring") {
+    throw new Error(`${path}.evaluationMode must be "pass-fail" or "scoring".`);
+  }
+  for (const [bindingIndex, bindingValue] of requireArray(suite.inputBindings, `${path}.inputBindings`).entries()) {
+    const binding = requireRecord(bindingValue, `${path}.inputBindings[${bindingIndex}]`);
+    requireString(binding.graphInputId, `${path}.inputBindings[${bindingIndex}].graphInputId`);
+    requireString(binding.datasetFieldId, `${path}.inputBindings[${bindingIndex}].datasetFieldId`);
+  }
+  for (const [assertionIndex, assertionValue] of requireArray(suite.assertions, `${path}.assertions`).entries()) {
+    const assertionPath = `${path}.assertions[${assertionIndex}]`;
+    const assertion = requireRecord(assertionValue, assertionPath);
+    for (const key of ["id", "outputPath"]) requireString(assertion[key], `${assertionPath}.${key}`);
+    requireText(assertion.name, `${assertionPath}.name`);
+    if (typeof assertion.operator !== "string" || !ASSERTION_OPERATORS.has(assertion.operator)) {
+      throw new Error(`${assertionPath}.operator is not supported.`);
+    }
+    validateOptionalPrimitive(assertion, "required", "boolean", assertionPath);
+    const expected = requireRecord(assertion.expected, `${assertionPath}.expected`);
+    if (expected.kind === "literal") {
+      if (!Object.hasOwn(expected, "value")) throw new Error(`${assertionPath}.expected.value is required.`);
+    } else if (expected.kind === "dataset-field") {
+      requireString(expected.fieldId, `${assertionPath}.expected.fieldId`);
+    } else {
+      throw new Error(`${assertionPath}.expected.kind must be "literal" or "dataset-field".`);
+    }
+  }
+  for (const [evaluatorIndex, evaluatorValue] of requireArray(suite.evaluators, `${path}.evaluators`).entries()) {
+    const evaluatorPath = `${path}.evaluators[${evaluatorIndex}]`;
+    const evaluator = requireRecord(evaluatorValue, evaluatorPath);
+    for (const key of ["id", "graphId"]) requireString(evaluator[key], `${evaluatorPath}.${key}`);
+    requireText(evaluator.name, `${evaluatorPath}.name`);
+    validateOptionalPrimitive(evaluator, "required", "boolean", evaluatorPath);
+    validateOptionalPrimitive(evaluator, "runOnTargetError", "boolean", evaluatorPath);
+    validateOptionalPrimitive(evaluator, "scoreWeight", "number", evaluatorPath);
+    if (evaluator.inputBindings !== void 0) {
+      for (const [bindingIndex, bindingValue] of requireArray(
+        evaluator.inputBindings,
+        `${evaluatorPath}.inputBindings`
+      ).entries()) {
+        const bindingPath = `${evaluatorPath}.inputBindings[${bindingIndex}]`;
+        const binding = requireRecord(bindingValue, bindingPath);
+        requireString(binding.graphInputId, `${bindingPath}.graphInputId`);
+        const source = requireRecord(binding.source, `${bindingPath}.source`);
+        if (source.kind === "dataset-field") requireString(source.fieldId, `${bindingPath}.source.fieldId`);
+        else if (source.kind === "target-output") requireString(source.outputId, `${bindingPath}.source.outputId`);
+        else if (source.kind === "context") {
+          if (typeof source.context !== "string" || !EVALUATOR_CONTEXT_INPUTS.has(source.context)) {
+            throw new Error(`${bindingPath}.source.context is not supported.`);
+          }
+        } else {
+          throw new Error(`${bindingPath}.source.kind is not supported.`);
+        }
+      }
+    }
+  }
+  if (suite.thresholds !== void 0) {
+    for (const [thresholdIndex, thresholdValue2] of requireArray(suite.thresholds, `${path}.thresholds`).entries()) {
+      const thresholdPath = `${path}.thresholds[${thresholdIndex}]`;
+      const threshold = requireRecord(thresholdValue2, thresholdPath);
+      for (const key of ["id", "metric", "operator"]) requireString(threshold[key], `${thresholdPath}.${key}`);
+      requireFiniteNumber(threshold.value, `${thresholdPath}.value`);
+    }
+  }
+  if (suite.configuration !== void 0) {
+    const configuration = requireRecord(suite.configuration, `${path}.configuration`);
+    for (const key of ["trialCount", "concurrency", "timeoutMs", "seed"]) {
+      validateOptionalPrimitive(configuration, key, "number", `${path}.configuration`);
+    }
+    validateOptionalPrimitive(configuration, "seedGraphInputId", "string", `${path}.configuration`);
+    validateOptionalPrimitive(configuration, "recordingRetention", "string", `${path}.configuration`);
+  }
+  validateOptionalPrimitive(suite, "description", "string", path);
+  if (suite.tags !== void 0) {
+    for (const [tagIndex, tag] of requireArray(suite.tags, `${path}.tags`).entries()) {
+      requireString(tag, `${path}.tags[${tagIndex}]`);
+    }
+  }
+}
+function validateNumericRecord(value, path) {
+  const record = requireRecord(value, path);
+  for (const [key, entry] of Object.entries(record)) requireFiniteNumber(entry, `${path}.${key}`);
+}
+function validateBaselineShape(value, index) {
+  const path = `evaluations.baselines[${index}]`;
+  const baseline = requireRecord(value, path);
+  for (const key of ["id", "suiteId", "createdAt"]) requireString(baseline[key], `${path}.${key}`);
+  validateOptionalPrimitive(baseline, "sourceRunId", "string", path);
+  if (baseline.evaluationMode !== void 0 && baseline.evaluationMode !== "pass-fail" && baseline.evaluationMode !== "scoring") {
+    throw new Error(`${path}.evaluationMode must be "pass-fail" or "scoring".`);
+  }
+  const provenance = requireRecord(baseline.provenance, `${path}.provenance`);
+  for (const key of [
+    "projectFingerprint",
+    "suiteFingerprint",
+    "datasetFingerprint",
+    "targetFingerprint",
+    "executionMode"
+  ]) {
+    requireString(provenance[key], `${path}.provenance.${key}`);
+  }
+  const evaluatorFingerprints = requireRecord(
+    provenance.evaluatorFingerprints,
+    `${path}.provenance.evaluatorFingerprints`
+  );
+  for (const [key, fingerprint2] of Object.entries(evaluatorFingerprints)) {
+    requireString(fingerprint2, `${path}.provenance.evaluatorFingerprints.${key}`);
+  }
+  requireBoolean(provenance.accountingComplete, `${path}.provenance.accountingComplete`);
+  const aggregate2 = requireRecord(baseline.aggregate, `${path}.aggregate`);
+  for (const key of [
+    "trialCount",
+    "passedTrialCount",
+    "failedTrialCount",
+    "erroredTrialCount",
+    "canceledTrialCount",
+    "passRate",
+    "averageLatencyMs",
+    "p95LatencyMs",
+    "targetErrorRate",
+    "evaluatorErrorRate",
+    "toolFailureRate"
+  ]) {
+    requireFiniteNumber(aggregate2[key], `${path}.aggregate.${key}`);
+  }
+  for (const key of [
+    "evaluatedTrialCount",
+    "notEvaluatedTrialCount",
+    "unableToEvaluateTrialCount",
+    "meanScore",
+    "totalCostUsd",
+    "averageCostUsd",
+    "scoredTrialCount",
+    "missingScoreTrialCount"
+  ]) {
+    validateOptionalPrimitive(aggregate2, key, "number", `${path}.aggregate`);
+  }
+  validateNumericRecord(aggregate2.metrics, `${path}.aggregate.metrics`);
+  for (const [caseIndex, caseValue] of requireArray(baseline.cases, `${path}.cases`).entries()) {
+    const casePath = `${path}.cases[${caseIndex}]`;
+    const caseAggregate = requireRecord(caseValue, casePath);
+    requireString(caseAggregate.caseId, `${casePath}.caseId`);
+    requireString(caseAggregate.caseName, `${casePath}.caseName`);
+    validateNumericRecord(caseAggregate.metrics, `${casePath}.metrics`);
+    for (const key of [
+      "passRate",
+      "meanScore",
+      "evaluatedTrialCount",
+      "passedTrialCount",
+      "failedTrialCount",
+      "notEvaluatedTrialCount",
+      "unableToEvaluateTrialCount",
+      "erroredTrialCount",
+      "canceledTrialCount",
+      "scoredTrialCount",
+      "missingScoreTrialCount"
+    ]) {
+      validateOptionalPrimitive(caseAggregate, key, "number", casePath);
+    }
+  }
+}
+function createEmptyEvaluationProjectData() {
+  return { version: 1, suites: [], baselines: [] };
+}
+function serializeEvaluationProjectData(data) {
+  if (data.version !== 1) throw new Error(`Unsupported evaluation data version: ${data.version}`);
+  const persistentData = stripLegacyEditorSelections(data);
+  assertPortableJson(persistentData);
+  return {
+    ...structuredClone(persistentData),
+    baselines: persistentData.baselines.map(normalizeEvaluationBaselineSnapshot)
+  };
+}
+function deserializeEvaluationProjectData(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data))
+    throw new Error("Evaluation project data must be an object.");
+  const candidate = data;
+  if (candidate.version !== 1 || !Array.isArray(candidate.suites) || !Array.isArray(candidate.baselines)) {
+    throw new Error("Unsupported or invalid evaluation project data.");
+  }
+  const persistentData = stripLegacyEditorSelections(candidate);
+  assertPortableJson(persistentData);
+  persistentData.suites.forEach(validateSuiteShape);
+  persistentData.baselines.forEach(validateBaselineShape);
+  return {
+    ...structuredClone(persistentData),
+    baselines: persistentData.baselines.map(normalizeEvaluationBaselineSnapshot)
+  };
+}
+function serializeEvaluationProjectDataToString(data) {
+  return yaml.stringify(serializeEvaluationProjectData(data), null, 2);
+}
+function deserializeEvaluationProjectDataFromString(data) {
+  return deserializeEvaluationProjectData(yaml.parse(data));
+}
+
+// src/datasetTransfer.ts
+var DATASET_EXPORT_VERSION = 1;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString2(value, path) {
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${path} must be a non-empty string.`);
+  return value;
+}
+function requireText2(value, path) {
+  if (typeof value !== "string") throw new Error(`${path} must be a string.`);
+  return value;
+}
+function parseFields(value) {
+  if (!Array.isArray(value)) throw new Error("Evaluation dataset fields must be an array.");
+  const ids = /* @__PURE__ */ new Set();
+  return value.map((field, index) => {
+    if (!isRecord3(field)) throw new Error(`fields[${index}] must be an object.`);
+    const id = requireString2(field.id, `fields[${index}].id`);
+    if (ids.has(id)) throw new Error(`Evaluation dataset has duplicate field id "${id}".`);
+    ids.add(id);
+    const role = field.role;
+    if (role !== "input" && role !== "expected" && role !== "metadata") {
+      throw new Error(`fields[${index}].role must be input, expected, or metadata.`);
+    }
+    if (field.description !== void 0 && typeof field.description !== "string") {
+      throw new Error(`fields[${index}].description must be a string.`);
+    }
+    if (field.required !== void 0 && typeof field.required !== "boolean") {
+      throw new Error(`fields[${index}].required must be a boolean.`);
+    }
+    return {
+      id,
+      name: requireText2(field.name, `fields[${index}].name`),
+      dataType: requireString2(field.dataType, `fields[${index}].dataType`),
+      role,
+      ...typeof field.description === "string" ? { description: field.description } : {},
+      ...typeof field.required === "boolean" ? { required: field.required } : {}
+    };
+  });
+}
+function parseCases(value, fieldIds) {
+  if (!Array.isArray(value)) throw new Error("Evaluation dataset cases must be an array.");
+  const ids = /* @__PURE__ */ new Set();
+  return value.map((testCase, index) => {
+    if (!isRecord3(testCase)) throw new Error(`cases[${index}] must be an object.`);
+    const id = requireString2(testCase.id, `cases[${index}].id`);
+    if (ids.has(id)) throw new Error(`Evaluation dataset has duplicate case id "${id}".`);
+    ids.add(id);
+    if (!isRecord3(testCase.values)) throw new Error(`cases[${index}].values must be an object.`);
+    for (const [fieldId, fieldValue] of Object.entries(testCase.values)) {
+      if (!fieldIds.has(fieldId)) throw new Error(`cases[${index}].values references unknown field "${fieldId}".`);
+      assertPortableJson(fieldValue, `cases[${index}].values.${fieldId}`);
+    }
+    if (testCase.tags !== void 0 && (!Array.isArray(testCase.tags) || testCase.tags.some((tag) => typeof tag !== "string"))) {
+      throw new Error(`cases[${index}].tags must be an array of strings.`);
+    }
+    if (testCase.note !== void 0 && typeof testCase.note !== "string") throw new Error(`cases[${index}].note must be a string.`);
+    if (testCase.enabled !== void 0 && typeof testCase.enabled !== "boolean") throw new Error(`cases[${index}].enabled must be a boolean.`);
+    return {
+      id,
+      name: requireText2(testCase.name, `cases[${index}].name`),
+      values: testCase.values,
+      ...typeof testCase.enabled === "boolean" ? { enabled: testCase.enabled } : {},
+      ...Array.isArray(testCase.tags) ? { tags: testCase.tags } : {},
+      ...typeof testCase.note === "string" ? { note: testCase.note } : {}
+    };
+  });
+}
+function validateEvaluationDataset(value, scope) {
+  if (!isRecord3(value)) throw new Error("Evaluation dataset must be an object.");
+  const fields = parseFields(value.fields);
+  const importedProjectId = value.projectId === void 0 ? void 0 : requireString2(value.projectId, "dataset.projectId");
+  const projectId = (scope == null ? void 0 : scope.projectId) ?? importedProjectId;
+  const dataset = {
+    id: (scope == null ? void 0 : scope.id) ?? requireString2(value.id, "dataset.id"),
+    name: requireText2(value.name, "dataset.name"),
+    ...projectId === void 0 ? {} : { projectId },
+    fields,
+    cases: parseCases(value.cases, new Set(fields.map((field) => field.id)))
+  };
+  return { ...dataset, contentFingerprint: fingerprintEvaluationDataset(dataset) };
+}
+function localizeEvaluationDataset(value, id) {
+  const dataset = validateEvaluationDataset(value, id === void 0 ? void 0 : { id });
+  const { projectId: _legacyProjectId, ...localDataset } = dataset;
+  return { ...localDataset, contentFingerprint: fingerprintEvaluationDataset(localDataset) };
+}
+function validateEvaluationDatasetForTransfer(value, scope) {
+  const dataset = validateEvaluationDataset(value, scope);
+  assertEvaluationDatasetValuesMatchDeclaredTypes(dataset);
+  return dataset;
+}
+function serializeEvaluationDatasetJson(dataset) {
+  const validated = validateEvaluationDatasetForTransfer(dataset);
+  return JSON.stringify({ version: DATASET_EXPORT_VERSION, dataset: validated }, null, 2);
+}
+function deserializeEvaluationDatasetJson(source, scope) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new Error("Evaluation dataset JSON is not valid JSON.");
+  }
+  if (!isRecord3(parsed) || parsed.version !== DATASET_EXPORT_VERSION || !isRecord3(parsed.dataset)) {
+    throw new Error(`Expected an evaluation dataset export with version ${DATASET_EXPORT_VERSION}.`);
+  }
+  const dataset = validateEvaluationDatasetForTransfer(parsed.dataset, { id: scope.id });
+  const { projectId: _legacyProjectId, ...localDataset } = dataset;
+  return { ...localDataset, contentFingerprint: fingerprintEvaluationDataset(localDataset) };
+}
+
+// src/suiteTransfer.ts
+var SUITE_BUNDLE_EXPORT_VERSION = 1;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireNonEmptyString(value, name) {
+  if (value.trim().length === 0) throw new Error(`${name} must be a non-empty string.`);
+}
+function validateEvaluationSuite(value) {
+  return deserializeEvaluationProjectData({ version: 1, suites: [value], baselines: [] }).suites[0];
+}
+function validateBundle(value) {
+  if (!isRecord4(value) || value.version !== SUITE_BUNDLE_EXPORT_VERSION || !isRecord4(value.suite) || !isRecord4(value.dataset)) {
+    throw new Error(`Expected an evaluation suite export with version ${SUITE_BUNDLE_EXPORT_VERSION}.`);
+  }
+  const suite = validateEvaluationSuite(value.suite);
+  const dataset = validateEvaluationDatasetForTransfer(value.dataset);
+  if (suite.datasetId !== dataset.id) {
+    throw new Error("The evaluation suite export must include the dataset referenced by its suite.");
+  }
+  return { suite, dataset };
+}
+function serializeEvaluationSuiteBundleJson(suite, dataset) {
+  const bundle = validateBundle({ version: SUITE_BUNDLE_EXPORT_VERSION, suite, dataset });
+  return JSON.stringify(
+    { version: SUITE_BUNDLE_EXPORT_VERSION, ...bundle },
+    null,
+    2
+  );
+}
+function deserializeEvaluationSuiteBundleJson(source, scope) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new Error("Evaluation suite JSON is not valid JSON.");
+  }
+  requireNonEmptyString(scope.suiteId, "suiteId");
+  requireNonEmptyString(scope.datasetId, "datasetId");
+  const bundle = validateBundle(parsed);
+  const dataset = localizeEvaluationDataset(bundle.dataset, scope.datasetId);
+  return {
+    dataset,
+    suite: {
+      ...bundle.suite,
+      id: scope.suiteId,
+      datasetId: dataset.id
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvaluationGraphExecutionError,
+  InMemoryEvaluationRunStore,
+  LEGACY_EVALUATOR_INPUT_IDS,
+  areEvaluationDataTypesCompatible,
+  assertEvaluationDatasetSnapshot,
+  assertEvaluationDatasetValuesMatchDeclaredTypes,
+  assertPortableJson,
+  canonicalStringify,
+  canonicalizePortableJson,
+  clonePortableJson,
+  createEmptyEvaluationProjectData,
+  createEmptyMetrics,
+  createEvaluationBaselineSnapshot,
+  deserializeEvaluationDatasetJson,
+  deserializeEvaluationProjectData,
+  deserializeEvaluationProjectDataFromString,
+  deserializeEvaluationSuiteBundleJson,
+  evaluateAssertion,
+  evaluateThresholdResults,
+  finalizeEvaluationRecordingRetention,
+  fingerprint,
+  fingerprintEvaluationDataset,
+  getEvaluationSuiteMode,
+  getEvaluationTopLevelOutputId,
+  hasAuthoritativeEvaluationCriteria,
+  isEvaluationOutputPathSyntaxValid,
+  isEvaluationValueCompatibleWithDataType,
+  isPortableEvaluationDataType,
+  localizeEvaluationDataset,
+  normalizeEvaluationAggregate,
+  normalizeEvaluationBaselineSnapshot,
+  normalizeEvaluationRun,
+  normalizeEvaluationTrial,
+  portableEvaluationDataTypes,
+  runEvaluationCases,
+  runEvaluationSuite,
+  runEvaluationWorkPool,
+  serializeEvaluationDatasetJson,
+  serializeEvaluationProjectData,
+  serializeEvaluationProjectDataToString,
+  serializeEvaluationSuiteBundleJson,
+  shouldReplaceEvaluationRun,
+  summarizeEvaluationRun,
+  usesLegacyEvaluatorInputEnvelope,
+  validateEvaluationAssertionConfiguration,
+  validateEvaluationAssertionExpectedValue,
+  validateEvaluationDataset,
+  validateEvaluationDatasetForTransfer
+});
+//# sourceMappingURL=bundle.cjs.map