raindrop-ai 0.4.0 → 0.5.0

package/dist/chunk-HFHHGRTW.mjs

@@ -0,0 +1,1201 @@
+// src/evals/definition.ts
+import { z } from "zod";
+var EvalScoreSchema = z.union([
+  z.literal(1),
+  z.literal(2),
+  z.literal(3),
+  z.literal(4),
+  z.literal(5)
+]);
+var EVAL_DATASET = /* @__PURE__ */ Symbol.for("raindrop.evalDataset");
+function defineDataset(dataset) {
+  const id = dataset.id.trim();
+  const name = dataset.name.trim();
+  const version = dataset.version.trim();
+  if (!id) throw new Error("Raindrop eval dataset ids cannot be empty");
+  if (!name) throw new Error("Raindrop eval dataset names cannot be empty");
+  if (!version) throw new Error("Raindrop eval dataset versions cannot be empty");
+  if (dataset.cases.length === 0)
+    throw new Error("Raindrop eval datasets require at least one case");
+  const ids = dataset.cases.map((entry) => entry.id.trim());
+  if (ids.some((caseId) => !caseId)) throw new Error("Raindrop eval case ids cannot be empty");
+  if (new Set(ids).size !== ids.length) throw new Error("Raindrop eval case ids must be unique");
+  if (dataset.remote) {
+    if (!dataset.remote.reference.trim())
+      throw new Error("Raindrop remote dataset reference cannot be empty");
+    if (!/^[a-f0-9]{64}$/.test(dataset.remote.fingerprint)) {
+      throw new Error("Raindrop remote dataset fingerprint must be a SHA-256 digest");
+    }
+  }
+  const defined = {
+    ...dataset,
+    id,
+    name,
+    version,
+    cases: dataset.cases.map((entry) => ({ ...entry, id: entry.id.trim() })),
+    [EVAL_DATASET]: true
+  };
+  Object.defineProperty(defined, EVAL_DATASET, { enumerable: false });
+  return defined;
+}
+function isEvalDataset(value) {
+  return typeof value === "object" && value !== null && EVAL_DATASET in value && value[EVAL_DATASET] === true;
+}
+var BooleanThresholdSchema = z.object({ equals: z.boolean() }).strict();
+var FiniteThresholdSchema = z.number().finite();
+var EvalOutputSchema = z.enum(["boolean", "score", "number"]);
+var NumericThresholdSchema = z.union([
+  z.object({ gte: FiniteThresholdSchema, lte: FiniteThresholdSchema.optional() }).strict(),
+  z.object({ lte: FiniteThresholdSchema }).strict()
+]).refine(
+  (threshold) => !("gte" in threshold) || threshold.lte === void 0 || threshold.gte <= threshold.lte,
+  { message: "Lower threshold cannot exceed upper threshold" }
+);
+function defineEvaluatorProgram(program) {
+  var _a, _b, _c;
+  const slug = program.slug.trim();
+  const name = program.name.trim();
+  const source = program.source.trim();
+  const intent = program.intent.trim();
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) || slug.length > 64) {
+    throw new Error(
+      "Raindrop evaluator program slugs must use lowercase letters, numbers, and single hyphens"
+    );
+  }
+  if (!name || name.length > 120) {
+    throw new Error("Raindrop evaluator program names must be between 1 and 120 characters");
+  }
+  if (!source) throw new Error(`Raindrop evaluator program ${slug} source cannot be empty`);
+  if (!intent || intent.length > 1e4) {
+    throw new Error(
+      `Raindrop evaluator program ${slug} intent must be between 1 and 10000 characters`
+    );
+  }
+  if (program.description != null && program.description.trim().length > 2e3) {
+    throw new Error(`Raindrop evaluator program ${slug} description exceeds 2000 characters`);
+  }
+  const rules = (_b = (_a = program.rules) == null ? void 0 : _a.map((rule) => rule.trim())) != null ? _b : [];
+  if (rules.length > 12 || rules.some((rule) => !rule || rule.length > 2e3)) {
+    throw new Error(`Raindrop evaluator program ${slug} rules are invalid`);
+  }
+  if (program.expected && (!z.string().uuid().safeParse(program.expected.evalId).success || !Number.isInteger(program.expected.programVersion) || program.expected.programVersion <= 0)) {
+    throw new Error(`Raindrop evaluator program ${slug} expected identity is invalid`);
+  }
+  return {
+    ...program,
+    kind: "program",
+    slug,
+    name,
+    source,
+    intent,
+    description: ((_c = program.description) == null ? void 0 : _c.trim()) || null,
+    rules
+  };
+}
+function defineLocalEvaluator(evaluator) {
+  return evaluator;
+}
+var EVAL_DEFINITION = /* @__PURE__ */ Symbol.for("raindrop.evalDefinition");
+function defineEvalSuite(definition) {
+  const name = definition.name.trim();
+  if (name.length === 0) throw new Error("Raindrop eval suite names cannot be empty");
+  const dataset = typeof definition.dataset === "string" ? definition.dataset.trim() : defineDataset(definition.dataset);
+  if (typeof dataset === "string" && dataset.length === 0) {
+    throw new Error("Raindrop eval suite datasets cannot be empty");
+  }
+  if (typeof definition.run !== "function") {
+    throw new Error("Raindrop eval suite run must be a function");
+  }
+  if (!Array.isArray(definition.evaluators) || definition.evaluators.length === 0) {
+    throw new Error("Raindrop eval suites require at least one evaluator");
+  }
+  validateOptionalNumber("concurrency", definition.concurrency, true, false);
+  validateOptionalNumber("traceWaitMs", definition.traceWaitMs, false, true);
+  validateOptionalNumber("evalWaitMs", definition.evalWaitMs, false, true);
+  validateOptionalNumber("evalPollIntervalMs", definition.evalPollIntervalMs, false, false);
+  const evaluators = definition.evaluators.map((evaluator) => validateEvaluator(evaluator));
+  const evaluatorNames = evaluators.map((entry) => evaluatorName(entry));
+  if (new Set(evaluatorNames).size !== evaluatorNames.length) {
+    throw new Error("Raindrop eval suite evaluators must be unique");
+  }
+  const branded = {
+    ...definition,
+    [EVAL_DEFINITION]: true,
+    name,
+    dataset,
+    evaluators
+  };
+  Object.defineProperty(branded, EVAL_DEFINITION, { enumerable: false });
+  return branded;
+}
+function isEvalSuiteDefinition(value) {
+  return typeof value === "object" && value !== null && EVAL_DEFINITION in value && value[EVAL_DEFINITION] === true;
+}
+function evaluatorName(evaluator) {
+  return typeof evaluator.evaluator === "string" ? evaluator.evaluator.trim() : evaluator.evaluator.slug.trim();
+}
+function evaluatorOutput(evaluator) {
+  return typeof evaluator.evaluator === "string" ? void 0 : evaluator.evaluator.output;
+}
+function validateEvaluatorOutput(evaluator, rawOutput) {
+  const name = evaluatorName(evaluator);
+  const output = EvalOutputSchema.parse(rawOutput);
+  const localOutput = evaluatorOutput(evaluator);
+  if (localOutput !== void 0 && localOutput !== output) {
+    throw new Error(`Raindrop local evaluator ${name} expected ${localOutput}, received ${output}`);
+  }
+  switch (output) {
+    case "boolean":
+      parseBooleanThreshold(evaluator.threshold);
+      break;
+    case "score":
+      parseNumericThreshold(name, "score", evaluator.threshold);
+      break;
+    case "number":
+      parseNumericThreshold(name, "number", evaluator.threshold);
+      break;
+  }
+}
+function validateEvaluator(evaluator) {
+  if (typeof evaluator !== "object" || evaluator === null || !("evaluator" in evaluator)) {
+    throw new Error("Raindrop eval evaluator entries must name an evaluator");
+  }
+  if ("output" in evaluator) {
+    throw new Error(
+      "Raindrop eval evaluator entries do not accept output; the evaluator definition owns it"
+    );
+  }
+  if (typeof evaluator.evaluator !== "string" && (typeof evaluator.evaluator !== "object" || evaluator.evaluator === null || typeof evaluator.evaluator.slug !== "string" || typeof evaluator.evaluator.name !== "string")) {
+    throw new Error("Raindrop local eval evaluators require a slug, name, output, and judge");
+  }
+  const name = evaluatorName(evaluator);
+  if (name.length === 0) throw new Error("Raindrop eval evaluator names cannot be empty");
+  if (typeof evaluator.evaluator === "string") {
+    const threshold = evaluator.threshold;
+    if (threshold !== void 0) {
+      const boolean = BooleanThresholdSchema.safeParse(threshold);
+      const numeric = NumericThresholdSchema.safeParse(threshold);
+      if (!boolean.success && !numeric.success) {
+        throw new Error(`Raindrop hosted evaluator ${name} has an invalid threshold`);
+      }
+    }
+    return { ...evaluator, evaluator: name };
+  }
+  if ("kind" in evaluator.evaluator && evaluator.evaluator.kind === "portable") {
+    validateEvaluatorOutput(evaluator, evaluator.evaluator.output);
+    return evaluator;
+  }
+  if ("kind" in evaluator.evaluator && evaluator.evaluator.kind === "program") {
+    const program = defineEvaluatorProgram(evaluator.evaluator);
+    validateEvaluatorOutput({ ...evaluator, evaluator: program }, program.output);
+    return { ...evaluator, evaluator: program };
+  }
+  if (typeof evaluator.evaluator.judge !== "function") {
+    throw new Error(`Raindrop local evaluator ${name} judge must be a function`);
+  }
+  if (evaluator.evaluator.scope !== "case") {
+    throw new Error(`Raindrop local evaluator ${name} scope must be case`);
+  }
+  const output = EvalOutputSchema.parse(evaluator.evaluator.output);
+  validateEvaluatorOutput(evaluator, output);
+  return evaluator;
+}
+function validateOptionalNumber(name, value, integer, allowZero) {
+  if (value === void 0) return;
+  const valid = Number.isFinite(value) && (!integer || Number.isInteger(value)) && (allowZero ? value >= 0 : value > 0);
+  if (!valid) {
+    const kind = integer ? "a positive integer" : allowZero ? "non-negative" : "positive";
+    throw new Error(`Raindrop eval ${name} must be ${kind}`);
+  }
+}
+function parseBooleanThreshold(threshold) {
+  return threshold === void 0 ? void 0 : BooleanThresholdSchema.parse(threshold);
+}
+function parseNumericThreshold(name, output, threshold) {
+  const parsed = threshold === void 0 ? void 0 : NumericThresholdSchema.parse(threshold);
+  if (output === "score" && parsed) {
+    const lower = "gte" in parsed ? parsed.gte : void 0;
+    const inRange = (lower === void 0 || lower >= 1 && lower <= 5) && (parsed.lte === void 0 || parsed.lte >= 1 && parsed.lte <= 5);
+    if (!inRange)
+      throw new Error(`Raindrop score evaluator ${name} thresholds must be from 1 to 5`);
+  }
+  return parsed;
+}
+
+// src/evals/generated/trace.ts
+import z2 from "zod";
+var stringToJSONSchema = z2.string().transform((str, ctx) => {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    ctx.addIssue({ code: "custom", message: "Invalid JSON" });
+    return z2.NEVER;
+  }
+});
+var SignalPropertiesSchema = z2.union([stringToJSONSchema, z2.record(z2.unknown())]);
+var AIEventMetadataSchema = z2.object({
+  input: z2.string().optional().nullable(),
+  output: z2.string().optional().nullable(),
+  model: z2.string().optional().nullable(),
+  convoId: z2.string().optional().nullable()
+});
+var AnalyticsEventSchema = z2.object({
+  name: z2.string(),
+  timestamp: z2.string(),
+  receivedAt: z2.string(),
+  id: z2.string(),
+  properties: z2.record(z2.unknown()).nullable(),
+  userId: z2.string(),
+  isPending: z2.boolean().optional()
+});
+var LensInfoSchema = z2.object({
+  lensId: z2.coerce.number(),
+  sourceId: z2.string(),
+  source: z2.string().optional(),
+  categoryId: z2.coerce.number()
+});
+var AttachmentSchema = z2.object({
+  attachment_id: z2.string(),
+  attachment_type: z2.enum(["text", "image", "iframe"]).default("text"),
+  value: z2.string(),
+  name: z2.string().optional().default("")
+});
+var SignalSchema = z2.object({
+  id: z2.string().optional(),
+  name: z2.string(),
+  timestamp: z2.string(),
+  attachmentId: z2.string().optional(),
+  properties: SignalPropertiesSchema,
+  signalType: z2.string().optional(),
+  score: z2.number().optional()
+});
+var RichTextContentSchema = z2.object({
+  type: z2.literal("text"),
+  text: z2.string(),
+  annotations: z2.array(z2.object({
+    type: z2.enum(["url", "file", "event", "user", "signal"]),
+    text: z2.string().optional(),
+    id: z2.string().optional(),
+    url: z2.string().optional(),
+    startIndex: z2.number().int().optional(),
+    endIndex: z2.number().int().optional()
+  })).optional()
+});
+var RichJsonContentSchema = z2.object({
+  type: z2.literal("json"),
+  value: z2.unknown(),
+  raw: z2.string().nullable()
+});
+var RichMediaContentSchema = z2.object({
+  type: z2.enum(["image", "file"]),
+  mimeType: z2.string().optional(),
+  url: z2.string().optional(),
+  fileId: z2.string().optional(),
+  name: z2.string().optional()
+});
+var RichReferenceContentSchema = z2.object({
+  type: z2.literal("reference"),
+  label: z2.string(),
+  refType: z2.enum(["stored_tool_result", "external"]),
+  href: z2.string().optional(),
+  metadata: z2.record(z2.unknown()).optional()
+});
+var RichContentSchema = z2.union([
+  RichTextContentSchema,
+  RichJsonContentSchema,
+  RichMediaContentSchema,
+  RichReferenceContentSchema
+]);
+var RichPayloadValueSchema = z2.object({
+  kind: z2.enum(["empty", "text", "json", "reference"]),
+  raw: z2.string().nullable(),
+  truncated: z2.boolean(),
+  sizeChars: z2.number().int().nullable()
+});
+var RichEntrySourceSchema = z2.object({
+  adapter: z2.string(),
+  confidence: z2.enum(["high", "medium", "low"]),
+  spanIds: z2.array(z2.string()),
+  parentSpanIds: z2.array(z2.string()),
+  attributeKeys: z2.array(z2.string())
+});
+var RichInteractionEntryBaseSchema = z2.object({
+  id: z2.string(),
+  order: z2.number().int(),
+  startMs: z2.number().int().nullable(),
+  endMs: z2.number().int().nullable(),
+  source: RichEntrySourceSchema
+});
+var RichSystemEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("system"),
+  role: z2.enum(["system", "developer"]),
+  content: RichTextContentSchema,
+  collapsed: z2.literal(true),
+  tokenEstimate: z2.number().int().nullable()
+});
+var RichUserMessageEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("user_message"),
+  role: z2.literal("user"),
+  content: z2.array(RichContentSchema)
+});
+var RichAssistantTextEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("assistant_text"),
+  role: z2.literal("assistant"),
+  content: z2.array(RichContentSchema),
+  format: z2.enum(["markdown", "text"]),
+  final: z2.boolean()
+});
+var RichReasoningEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("reasoning"),
+  content: RichTextContentSchema,
+  format: z2.literal("text"),
+  visibility: z2.enum(["collapsed", "expanded"]),
+  capturedAs: z2.enum(["provider_reasoning", "reasoning_summary", "thinking", "unknown"])
+});
+var RichToolCallEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("tool_call"),
+  callId: z2.string().nullable(),
+  name: z2.string(),
+  status: z2.enum(["pending", "completed", "error", "unknown"]),
+  durationMs: z2.number().int().nullable(),
+  input: RichPayloadValueSchema,
+  output: RichPayloadValueSchema.nullable(),
+  error: RichPayloadValueSchema.nullable()
+});
+var RichUnknownSpanEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("unknown_span"),
+  spanType: z2.string().nullable(),
+  name: z2.string(),
+  hiddenByDefault: z2.literal(true)
+});
+var RichSubAgentEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("sub_agent"),
+  rootSpanId: z2.string(),
+  name: z2.string(),
+  spanIds: z2.array(z2.string()),
+  toolCount: z2.number().int(),
+  llmCount: z2.number().int(),
+  durationMs: z2.number().int().nullable(),
+  inputPreview: z2.string().nullable(),
+  outputPreview: z2.string().nullable(),
+  status: z2.enum(["ok", "error", "unknown"]),
+  model: z2.string().nullable(),
+  totalInputTokens: z2.number().int().nullable(),
+  totalOutputTokens: z2.number().int().nullable()
+});
+var RichDetachedSubAgentEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("detached_sub_agent"),
+  rootSpanId: z2.string(),
+  name: z2.string(),
+  durationMs: z2.number().int().nullable(),
+  inputPreview: z2.string().nullable(),
+  outputPreview: z2.string().nullable(),
+  status: z2.enum(["ok", "error", "unknown"]),
+  childEventId: z2.string()
+});
+var RichAgentHandoffEntrySchema = RichInteractionEntryBaseSchema.extend({
+  type: z2.literal("agent_handoff"),
+  fromAgent: z2.string(),
+  toAgent: z2.string(),
+  reason: z2.string().nullable()
+});
+var RichInteractionEntrySchema = z2.discriminatedUnion("type", [
+  RichSystemEntrySchema,
+  RichUserMessageEntrySchema,
+  RichAssistantTextEntrySchema,
+  RichReasoningEntrySchema,
+  RichToolCallEntrySchema,
+  RichSubAgentEntrySchema,
+  RichDetachedSubAgentEntrySchema,
+  RichAgentHandoffEntrySchema,
+  RichUnknownSpanEntrySchema
+]);
+var RichSpanSummarySchema = z2.object({
+  spanId: z2.string(),
+  parentSpanId: z2.string().nullable(),
+  traceId: z2.string(),
+  name: z2.string(),
+  spanType: z2.string().nullable(),
+  status: z2.string().nullable(),
+  startMs: z2.number().int().nullable(),
+  endMs: z2.number().int().nullable(),
+  durationMs: z2.number().int().nullable(),
+  model: z2.string().nullable(),
+  provider: z2.string().nullable(),
+  rendered: z2.boolean()
+});
+var RichDiagnosticWarningSchema = z2.object({
+  code: z2.enum([
+    "no_spans",
+    "missing_llm_input",
+    "missing_llm_output",
+    "duplicate_output_suppressed",
+    "tool_call_unmatched",
+    "payload_truncated",
+    "unknown_span_shape"
+  ]),
+  message: z2.string(),
+  spanIds: z2.array(z2.string()).optional()
+});
+var RichInteractionStatsSchema = z2.object({
+  agentCount: z2.number().int(),
+  llmCallCount: z2.number().int(),
+  toolCallCount: z2.number().int(),
+  errorCount: z2.number().int(),
+  agentNames: z2.array(z2.string())
+});
+var RichEventInteractionSchema = z2.object({
+  schemaVersion: z2.literal("2026-05-20"),
+  eventId: z2.string(),
+  traceIds: z2.array(z2.string()),
+  rootSpanIds: z2.array(z2.string()),
+  status: z2.enum(["complete", "partial", "missing_spans"]),
+  startedAt: z2.string().nullable(),
+  endedAt: z2.string().nullable(),
+  durationMs: z2.number().int().nullable(),
+  stats: RichInteractionStatsSchema,
+  entries: z2.array(RichInteractionEntrySchema),
+  spans: z2.array(RichSpanSummarySchema),
+  diagnostics: z2.object({
+    extractionVersion: z2.literal("rich-interaction/1"),
+    warnings: z2.array(RichDiagnosticWarningSchema),
+    unrenderedSpanCount: z2.number().int()
+  })
+});
+var CoreEventSchema = z2.object({
+  id: z2.string(),
+  _raindropDatabaseId: z2.string(),
+  projectId: z2.string().optional(),
+  name: z2.string(),
+  timestamp: z2.string(),
+  receivedAt: z2.string(),
+  userId: z2.string(),
+  aiData: AIEventMetadataSchema,
+  properties: z2.record(z2.unknown()).nullable()
+});
+var AIAnalyticsEventSchema = CoreEventSchema.extend({
+  customEventId: z2.string().optional().nullable(),
+  occurrencesInWindow: z2.number().optional(),
+  lensInfo: z2.array(LensInfoSchema).optional(),
+  topics: z2.array(z2.string()).optional(),
+  categories: z2.array(z2.tuple([z2.string(), z2.string().nullable(), z2.coerce.number().nullable()])).optional(),
+  categoryLog: z2.array(z2.object({
+    lensId: z2.coerce.number(),
+    categoryId: z2.coerce.string(),
+    action: z2.enum(["add_category", "remove_category", "skip_category"])
+  })).optional(),
+  inputAttachments: z2.array(z2.union([z2.string(), AttachmentSchema])).optional().transform((attachments) => (attachments == null ? void 0 : attachments.map((attachment) => {
+    if (typeof attachment === "string") {
+      try {
+        return AttachmentSchema.parse(JSON.parse(attachment));
+      } catch (e) {
+        return null;
+      }
+    }
+    return attachment;
+  }).filter((a) => a !== null)) || []),
+  outputAttachments: z2.array(z2.union([z2.string(), AttachmentSchema])).optional().transform((attachments) => (attachments == null ? void 0 : attachments.map((attachment) => {
+    if (typeof attachment === "string") {
+      try {
+        return AttachmentSchema.parse(JSON.parse(attachment));
+      } catch (e) {
+        return null;
+      }
+    }
+    return attachment;
+  }).filter((a) => a !== null)) || []),
+  signals: z2.array(SignalSchema).optional(),
+  errorSpans: z2.array(z2.object({
+    span_id: z2.string().optional(),
+    started_at: z2.string().optional(),
+    status: z2.string().optional(),
+    duration_ms: z2.coerce.number().optional(),
+    span_type: z2.string().optional(),
+    span_name: z2.string().optional(),
+    output_payload: z2.any().optional()
+  })).optional(),
+  regexSignals: z2.array(z2.string()).optional(),
+  toolCalls: z2.array(z2.any()).optional(),
+  toolCallNames: z2.array(z2.string()).optional(),
+  richInteraction: RichEventInteractionSchema.optional().nullable(),
+  _ai_output_words: z2.number().optional(),
+  _ai_input_words: z2.number().optional(),
+  userTraits: z2.record(z2.unknown()).optional().nullable(),
+  featureFlags: z2.record(z2.string()).optional().nullable(),
+  userCreatedAt: z2.string().optional().nullable(),
+  userPlan: z2.string().optional().nullable(),
+  userLastPlan: z2.string().optional().nullable(),
+  userPlanChangeTs: z2.string().optional().nullable(),
+  isPending: z2.boolean().optional()
+});
+var SpanStatusSchema = z2.enum(["UNSET", "OK", "ERROR"]);
+var SpanTypeSchema = z2.enum([
+  "INTERNAL",
+  "LLM_GENERATION",
+  "LLM_GENERATION_STREAM",
+  "TOOL_CALL"
+]);
+var TracesListPipe = {
+  name: "traces_list",
+  input: z2.object({
+    event_id: z2.string().optional(),
+    trace_id: z2.string().optional(),
+    subagent_parent_event_ids: z2.array(z2.string()).optional(),
+    limit: z2.number().int().optional(),
+    offset: z2.number().int().optional(),
+    trunc_len: z2.number().int().nonnegative().optional(),
+    span_type_filter: SpanTypeSchema.optional(),
+    span_status_filter: SpanStatusSchema.optional(),
+    span_id_filter: z2.string().optional(),
+    start_unix_ns_min: z2.string().optional(),
+    start_unix_ns_max: z2.string().optional()
+  }),
+  output: z2.object({
+    project_id: z2.string().optional(),
+    convo_id: z2.string(),
+    event_id: z2.string(),
+    custom_event_id: z2.string(),
+    trace_id: z2.string(),
+    span_id: z2.string(),
+    parent_span_id: z2.string(),
+    span_type: SpanTypeSchema,
+    span_name: z2.string(),
+    status: SpanStatusSchema,
+    input_payload: z2.string(),
+    output_payload: z2.string(),
+    start_unix_ns: z2.number(),
+    end_unix_ns: z2.number(),
+    duration_ns: z2.number(),
+    input_tokens: z2.number(),
+    output_tokens: z2.number(),
+    model: z2.string(),
+    provider: z2.string(),
+    attributes_string: z2.record(z2.string(), z2.string()),
+    attributes_num: z2.record(z2.string(), z2.number())
+  })
+};
+var UINT64_MAX = BigInt("18446744073709551615");
+var NANOSECONDS_PATTERN = /^\d{1,20}$/;
+var NanosecondsStringSchema = z2.string().refine((value) => {
+  if (!NANOSECONDS_PATTERN.test(value))
+    return false;
+  return BigInt(value) <= UINT64_MAX;
+}, "Nanoseconds must be a UInt64 decimal string");
+var ReplayTraceSnapshotSpanSchema = TracesListPipe.output.extend({
+  org_public_id: z2.string().uuid(),
+  project_id: z2.string().min(1),
+  user_id: z2.string(),
+  start_unix_ns: NanosecondsStringSchema,
+  timestamp: z2.string().min(1),
+  end_unix_ns: NanosecondsStringSchema,
+  end_timestamp: z2.string().min(1),
+  duration_ns: NanosecondsStringSchema,
+  _inserted_at: z2.string().min(1)
+}).strict();
+var TraceSchema = z2.object({
+  origin: z2.enum(["production", "dataset", "simulation", "replay"]),
+  event: AIAnalyticsEventSchema,
+  entries: z2.array(RichInteractionEntrySchema)
+});
+var CapturedTraceSpanSchema = ReplayTraceSnapshotSpanSchema;
+var EVAL_DATASET_MAX_SPANS_PER_TRACE = 500;
+var EvalDatasetCaseIdSchema = z2.string().min(1).max(512).refine((value) => value === value.trim(), "Case id cannot have surrounding whitespace");
+var CapturedTraceSnapshotSchema = z2.object({
+  event: AIAnalyticsEventSchema,
+  spans: z2.array(CapturedTraceSpanSchema).min(1).max(EVAL_DATASET_MAX_SPANS_PER_TRACE)
+}).strict().superRefine(({ event, spans }, context) => {
+  var _a;
+  const spanIds = /* @__PURE__ */ new Set();
+  const traceIds = /* @__PURE__ */ new Set();
+  for (const [index, span] of spans.entries()) {
+    if (!/^[0-9a-f]{32}$/.test(span.trace_id)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "Captured trace id must be a lowercase 32-character hexadecimal value",
+        path: ["spans", index, "trace_id"]
+      });
+    }
+    if (!/^[0-9a-f]{16}$/.test(span.span_id)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "Captured span id must be a lowercase 16-character hexadecimal value",
+        path: ["spans", index, "span_id"]
+      });
+    }
+    if (span.parent_span_id !== "" && !/^[0-9a-f]{16}$/.test(span.parent_span_id)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "Captured parent span id must be empty or lowercase hexadecimal",
+        path: ["spans", index, "parent_span_id"]
+      });
+    }
+    if (span.event_id.length === 0) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "Captured event id cannot be empty",
+        path: ["spans", index, "event_id"]
+      });
+    }
+    if (spanIds.has(span.span_id)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: `Duplicate span id ${span.span_id}`,
+        path: ["spans", index, "span_id"]
+      });
+    }
+    spanIds.add(span.span_id);
+    traceIds.add(span.trace_id);
+    if (span.event_id !== event._raindropDatabaseId) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "Span event identity does not match the captured event",
+        path: ["spans", index, "event_id"]
+      });
+    }
+    const validStart = /^\d{1,20}$/.test(span.start_unix_ns);
+    const validEnd = /^\d{1,20}$/.test(span.end_unix_ns);
+    if (validStart && validEnd && (BigInt(span.start_unix_ns) === BigInt(0) || BigInt(span.end_unix_ns) < BigInt(span.start_unix_ns))) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: "A captured span must have an end time at or after its start time",
+        path: ["spans", index, "end_unix_ns"]
+      });
+    }
+  }
+  if (traceIds.size !== 1) {
+    context.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "A reference snapshot must contain exactly one trace id",
+      path: ["spans"]
+    });
+  }
+  for (const [index, span] of spans.entries()) {
+    if (span.parent_span_id && !spanIds.has(span.parent_span_id)) {
+      context.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message: `Missing parent span ${span.parent_span_id}`,
+        path: ["spans", index, "parent_span_id"]
+      });
+    }
+  }
+  const parentBySpanId = new Map(spans.map((span) => [span.span_id, span.parent_span_id]));
+  for (const [index, span] of spans.entries()) {
+    const path = /* @__PURE__ */ new Set();
+    let spanId = span.span_id;
+    while (spanId !== "") {
+      if (path.has(spanId)) {
+        context.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: "Captured span parent relationships cannot contain a cycle",
+          path: ["spans", index, "parent_span_id"]
+        });
+        break;
+      }
+      path.add(spanId);
+      spanId = (_a = parentBySpanId.get(spanId)) != null ? _a : "";
+    }
+  }
+});
+var EvalCaseTraceSchema = z2.object({
+  snapshot: CapturedTraceSnapshotSchema,
+  trace: TraceSchema
+});
+var EvalCaseTracePairSchema = z2.object({
+  caseId: EvalDatasetCaseIdSchema,
+  candidate: EvalCaseTraceSchema.extend({
+    trace: TraceSchema.extend({ origin: z2.literal("replay") })
+  }),
+  reference: EvalCaseTraceSchema.extend({
+    trace: TraceSchema.extend({ origin: z2.literal("dataset") })
+  })
+});
+function compareNanoseconds(left, right) {
+  if (Number.isFinite(left) && Number.isFinite(right))
+    return Number(left) - Number(right);
+  const leftNs = BigInt(left != null ? left : 0);
+  const rightNs = BigInt(right != null ? right : 0);
+  return leftNs < rightNs ? -1 : leftNs > rightNs ? 1 : 0;
+}
+function nanosecondsToRoundedMilliseconds(value) {
+  if (Number.isFinite(value))
+    return Math.round(Number(value) / 1e6);
+  return Number((BigInt(value != null ? value : 0) + BigInt(5e5)) / BigInt(1e6));
+}
+var MAX_CUSTOM_ATTRIBUTES = 25;
+var MAX_ATTRIBUTE_VALUE_CHARS = 500;
+var KNOWN_ATTRIBUTE_PREFIXES = [
+  "ai.",
+  "gen_ai.",
+  "llm.",
+  "openinference.",
+  "traceloop.",
+  "raindrop.",
+  "otel.",
+  "telemetry.",
+  "service.",
+  "resource.",
+  "http.",
+  "net.",
+  "network.",
+  "server.",
+  "client.",
+  "url.",
+  "rpc.",
+  "db.",
+  "messaging.",
+  "code.",
+  "thread.",
+  "session.",
+  "user_agent.",
+  "process.",
+  "host.",
+  "os.",
+  "exception.",
+  "span."
+];
+var SENSITIVE_KEY_TOKENS = /* @__PURE__ */ new Set([
+  "secret",
+  "secrets",
+  "secretkey",
+  "password",
+  "passwd",
+  "pwd",
+  "token",
+  "tokens",
+  "auth",
+  "authorization",
+  "credential",
+  "credentials",
+  "bearer",
+  "cookie",
+  "cookies",
+  "apikey",
+  "accesskey",
+  "privatekey",
+  "sessionid"
+]);
+var SENSITIVE_KEY_TOKEN_PAIRS = /* @__PURE__ */ new Set([
+  "api key",
+  "access key",
+  "private key",
+  "secret key",
+  "session id",
+  "auth token",
+  "access token",
+  "refresh token"
+]);
+function isKnownAttributeKey(key) {
+  return KNOWN_ATTRIBUTE_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+function tokenizeKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((token) => token.toLowerCase());
+}
+function isSensitiveAttributeKey(key) {
+  const tokens = tokenizeKey(key);
+  if (tokens.some((token) => SENSITIVE_KEY_TOKENS.has(token)))
+    return true;
+  for (let index = 0; index < tokens.length - 1; index += 1) {
+    if (SENSITIVE_KEY_TOKEN_PAIRS.has(`${tokens[index]} ${tokens[index + 1]}`))
+      return true;
+  }
+  return false;
+}
+function extractCustomSpanAttributes(span) {
+  var _a, _b;
+  const attributes = {};
+  const strings = (_a = span.attributes_string) != null ? _a : {};
+  for (const [key, value] of Object.entries(strings)) {
+    if (Object.keys(attributes).length >= MAX_CUSTOM_ATTRIBUTES)
+      break;
+    if (isKnownAttributeKey(key) || isSensitiveAttributeKey(key)) {
+      continue;
+    }
+    attributes[key] = value.length > MAX_ATTRIBUTE_VALUE_CHARS ? `${value.slice(0, MAX_ATTRIBUTE_VALUE_CHARS)}\u2026` : value;
+  }
+  const numbers = (_b = span.attributes_num) != null ? _b : {};
+  for (const [key, value] of Object.entries(numbers)) {
+    if (Object.keys(attributes).length >= MAX_CUSTOM_ATTRIBUTES)
+      break;
+    if (isKnownAttributeKey(key) || isSensitiveAttributeKey(key)) {
+      continue;
+    }
+    attributes[key] = value;
+  }
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+}
+function extractFinishReason(span) {
+  var _a, _b, _c;
+  const strings = (_a = span.attributes_string) != null ? _a : {};
+  const value = (_c = (_b = strings["ai.response.finishReason"]) != null ? _b : strings["gen_ai.response.finish_reasons"]) != null ? _c : strings["llm.response.finish_reason"];
+  return value && value.length > 0 ? value : void 0;
+}
+function normalizePayload(value) {
+  return value != null ? value : void 0;
+}
+function buildTraceSteps(rawSpans, options = {}) {
+  var _a;
+  const includePayloads = (_a = options.includePayloads) != null ? _a : false;
+  const sorted = [...rawSpans].sort((left, right) => compareNanoseconds(left.start_unix_ns, right.start_unix_ns));
+  return sorted.map((span, index) => {
+    var _a2, _b;
+    const status = span.status === "OK" || span.status === "ERROR" ? span.status : "UNSET";
+    const step = {
+      step: index + 1,
+      type: span.span_type || "INTERNAL",
+      name: span.span_name || "unknown",
+      status,
+      duration_ms: nanosecondsToRoundedMilliseconds(span.duration_ns)
+    };
+    if (span.span_id)
+      step.span_id = span.span_id;
+    if (span.status === "ERROR" && span.output_payload) {
+      step.error = span.output_payload.slice(0, 500);
+    }
+    if (span.model)
+      step.model = span.model;
+    const finishReason = extractFinishReason(span);
+    if (finishReason)
+      step.finish_reason = finishReason;
+    if (((_a2 = span.input_tokens) != null ? _a2 : 0) > 0)
+      step.input_tokens = span.input_tokens;
+    if (((_b = span.output_tokens) != null ? _b : 0) > 0)
+      step.output_tokens = span.output_tokens;
+    if (includePayloads && step.type === "TOOL_CALL") {
+      const inputPayload = normalizePayload(span.input_payload);
+      const outputPayload = normalizePayload(span.output_payload);
+      if (inputPayload)
+        step.input_payload = inputPayload;
+      if (outputPayload)
+        step.output_payload = outputPayload;
+    }
+    const attributes = extractCustomSpanAttributes(span);
+    if (attributes)
+      step.attributes = attributes;
+    return step;
+  });
+}
+var MAX_EVAL_PAYLOAD_RAW_CHARS = 16 * 1024;
+function boundEvalPayload(payload) {
+  var _a;
+  if (payload.raw === null)
+    return payload;
+  const sizeChars = (_a = payload.sizeChars) != null ? _a : payload.raw.length;
+  return {
+    ...payload,
+    raw: payload.raw.slice(0, MAX_EVAL_PAYLOAD_RAW_CHARS),
+    sizeChars,
+    truncated: payload.truncated || sizeChars > MAX_EVAL_PAYLOAD_RAW_CHARS
+  };
+}
+function boundEvalEntry(entry) {
+  switch (entry.type) {
+    case "system":
+    case "reasoning":
+      return {
+        ...entry,
+        content: {
+          ...entry.content,
+          text: entry.content.text.slice(0, MAX_EVAL_PAYLOAD_RAW_CHARS)
+        }
+      };
+    case "user_message":
+    case "assistant_text":
+      return {
+        ...entry,
+        content: entry.content.map((content) => content.type === "text" ? { ...content, text: content.text.slice(0, MAX_EVAL_PAYLOAD_RAW_CHARS) } : content.type === "json" && content.raw !== null ? { ...content, raw: content.raw.slice(0, MAX_EVAL_PAYLOAD_RAW_CHARS) } : content)
+      };
+    case "tool_call":
+      return {
+        ...entry,
+        input: boundEvalPayload(entry.input),
+        output: entry.output === null ? null : boundEvalPayload(entry.output),
+        error: entry.error === null ? null : boundEvalPayload(entry.error)
+      };
+    default:
+      return entry;
+  }
+}
+function createTrace(origin, event, entries) {
+  return TraceSchema.parse({ origin, event, entries });
+}
+function traceStepsToEntries(steps) {
+  return steps.map((step, index) => {
+    var _a;
+    const source = {
+      adapter: "raw_spans",
+      confidence: "medium",
+      spanIds: step.span_id ? [step.span_id] : [],
+      parentSpanIds: [],
+      attributeKeys: []
+    };
+    const common = {
+      id: (_a = step.span_id) != null ? _a : `raw-step-${index}`,
+      order: index,
+      startMs: null,
+      endMs: null,
+      source
+    };
+    if (step.type === "TOOL_CALL") {
+      const payload = (raw) => {
+        var _a2;
+        return boundEvalPayload({
+          kind: raw ? "text" : "empty",
+          raw: raw != null ? raw : null,
+          truncated: false,
+          sizeChars: (_a2 = raw == null ? void 0 : raw.length) != null ? _a2 : null
+        });
+      };
+      return {
+        ...common,
+        type: "tool_call",
+        callId: null,
+        name: step.name,
+        status: step.status === "ERROR" ? "error" : step.status === "OK" ? "completed" : "unknown",
+        durationMs: step.duration_ms,
+        input: payload(step.input_payload),
+        output: step.output_payload ? payload(step.output_payload) : null,
+        error: step.error ? payload(step.error) : null
+      };
+    }
+    return {
+      ...common,
+      type: "unknown_span",
+      spanType: step.type,
+      name: step.name,
+      hiddenByDefault: true
+    };
+  });
+}
+function projectWorkshopTrace(input) {
+  return createTrace(input.origin, input.event, traceStepsToEntries(buildTraceSteps([...input.spans], { includePayloads: true })).map(boundEvalEntry));
+}
+function projectCapturedEvent(input) {
+  var _a, _b, _c, _d, _e, _f;
+  const ordered = [...input.spans].sort((left, right) => compareNanoseconds(left.start_unix_ns, right.start_unix_ns));
+  const eventSpan = ordered.find((span) => span.span_id === `evt_${input.eventId}`);
+  const llmSpans = ordered.filter((span) => span.span_type === "LLM_GENERATION" || span.span_type === "LLM_GENERATION_STREAM");
+  const inputSpan = ((_a = eventSpan == null ? void 0 : eventSpan.input_payload) == null ? void 0 : _a.trim()) ? eventSpan : llmSpans.find((span) => {
+    var _a2;
+    return Boolean((_a2 = span.input_payload) == null ? void 0 : _a2.trim());
+  });
+  const reverseLlmSpans = [...llmSpans].reverse();
+  const outputSpan = (_c = ((_b = eventSpan == null ? void 0 : eventSpan.output_payload) == null ? void 0 : _b.trim()) ? eventSpan : void 0) != null ? _c : reverseLlmSpans.find((span) => {
+    var _a2;
+    return Boolean((_a2 = span.output_payload) == null ? void 0 : _a2.trim()) && extractFinishReason(span) !== "tool-calls";
+  });
+  const modelSpan = (eventSpan == null ? void 0 : eventSpan.model) ? eventSpan : reverseLlmSpans.find((span) => Boolean(span.model));
+  return AIAnalyticsEventSchema.parse({
+    id: input.eventId,
+    _raindropDatabaseId: input.internalEventId,
+    name: input.name,
+    timestamp: input.timestamp,
+    receivedAt: input.receivedAt,
+    userId: input.userId,
+    aiData: {
+      input: (_d = inputSpan == null ? void 0 : inputSpan.input_payload) != null ? _d : null,
+      output: (_e = outputSpan == null ? void 0 : outputSpan.output_payload) != null ? _e : null,
+      model: (_f = modelSpan == null ? void 0 : modelSpan.model) != null ? _f : null,
+      convoId: input.convoId
+    },
+    properties: input.properties
+  });
+}
+function traceOutput(trace) {
+  var _a;
+  return (_a = trace.event.aiData.output) != null ? _a : null;
+}
+function traceToolCalls(trace, name) {
+  return trace.entries.filter((entry) => entry.type === "tool_call" && (name === void 0 || entry.name === name));
+}
+var TRACE_PROJECTION_SHA256 = "8dab83087aa2def3d076324021d5e08911e37967b68597b58b793a80d54b5874";
+
+// src/evals/portable.ts
+import { z as z3 } from "zod";
+var PortableEvalArtifactSchema = z3.object({
+  format: z3.literal("raindrop.eval-program"),
+  formatVersion: z3.literal(1),
+  runtimeAbi: z3.literal("raindrop-eval-v2"),
+  evaluator: z3.object({
+    id: z3.string().uuid(),
+    slug: z3.string().min(1),
+    programVersion: z3.number().int().positive(),
+    executionMode: z3.enum(["deterministic", "judge"]),
+    outputType: z3.enum(["boolean", "score", "number"]),
+    scope: z3.literal("batch")
+  }).strict(),
+  traceProjectionVersion: z3.literal(1),
+  traceProjectionSha256: z3.string().regex(/^[a-f0-9]{64}$/),
+  source: z3.string().min(1),
+  sha256: z3.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var PortableEvalResultSchema = z3.object({
+  outcomes: z3.array(
+    z3.union([
+      z3.object({
+        state: z3.literal("graded"),
+        traceId: z3.string(),
+        pass: z3.boolean(),
+        note: z3.string().optional()
+      }),
+      z3.object({
+        state: z3.literal("graded"),
+        traceId: z3.string(),
+        score: EvalScoreSchema,
+        note: z3.string().optional()
+      }),
+      z3.object({
+        state: z3.literal("graded"),
+        traceId: z3.string(),
+        value: z3.number().finite(),
+        note: z3.string().optional()
+      }),
+      z3.object({ state: z3.literal("errored"), traceId: z3.string(), message: z3.string() }),
+      z3.object({
+        state: z3.literal("ungraded"),
+        traceId: z3.string(),
+        reason: z3.enum(["not sampled", "trace unavailable", "content unreadable"])
+      })
+    ])
+  ),
+  failures: z3.array(z3.string()),
+  stats: z3.object({
+    traceCount: z3.number().int().nonnegative(),
+    hydratedCount: z3.number().int().nonnegative(),
+    judgeCalls: z3.number().int().nonnegative(),
+    durationMs: z3.number().nonnegative(),
+    skippedRows: z3.number().int().nonnegative(),
+    skippedReason: z3.literal("no trace").nullable()
+  })
+});
+function parsePortableEvalResult(value) {
+  return PortableEvalResultSchema.parse(value);
+}
+function importPortableEvaluator(rawArtifact, options = {}) {
+  var _a;
+  const artifact = PortableEvalArtifactSchema.parse(rawArtifact);
+  if (options.expectedSha256 && !/^[a-f0-9]{64}$/.test(options.expectedSha256)) {
+    throw new Error(
+      "Raindrop portable evaluator expectedSha256 must be a lowercase SHA-256 digest"
+    );
+  }
+  return {
+    kind: "portable",
+    artifact,
+    expectedSha256: options.expectedSha256,
+    judge: options.judge,
+    limits: options.limits,
+    slug: artifact.evaluator.slug,
+    name: ((_a = options.name) == null ? void 0 : _a.trim()) || artifact.evaluator.slug,
+    output: artifact.evaluator.outputType,
+    scope: artifact.evaluator.scope
+  };
+}
+async function evaluatePortableEvaluator(evaluator, input) {
+  var _a;
+  const artifact = await verifyPortableEvalArtifact(evaluator.artifact, {
+    expectedSha256: evaluator.expectedSha256
+  });
+  const { runPortableEvaluator } = await import("./portable-runtime-GBE3SHBZ.mjs");
+  const cases = (_a = input.cases) != null ? _a : [];
+  if (cases.length > 0 && (cases.length !== input.traces.length || cases.some(
+    (entry, index) => {
+      var _a2;
+      return entry.candidate.trace.event.id !== ((_a2 = input.traces[index]) == null ? void 0 : _a2.event.id);
+    }
+  ))) {
+    throw new Error("Raindrop portable evaluator cases must match traces exactly, in slice order");
+  }
+  const result = await runPortableEvaluator(evaluator, { ...input, cases });
+  validatePortableResult(artifact, input.traces, result);
+  return result;
+}
+async function verifyPortableEvalArtifact(rawArtifact, options = {}) {
+  const artifact = PortableEvalArtifactSchema.parse(rawArtifact);
+  if (artifact.traceProjectionSha256 !== TRACE_PROJECTION_SHA256) {
+    throw new Error(
+      `Raindrop portable evaluator ${artifact.evaluator.slug} targets a different trace projection`
+    );
+  }
+  const digest = await artifactDigest(artifact);
+  if (digest !== artifact.sha256) {
+    throw new Error(
+      `Raindrop portable evaluator ${artifact.evaluator.slug} content digest is invalid`
+    );
+  }
+  if (options.expectedSha256 && digest !== options.expectedSha256) {
+    throw new Error(
+      `Raindrop portable evaluator ${artifact.evaluator.slug} does not match expectedSha256`
+    );
+  }
+  return artifact;
+}
+function validatePortableResult(artifact, traces, result) {
+  if (result.stats.traceCount !== traces.length) {
+    throw new Error("Raindrop portable evaluator returned an inconsistent trace count");
+  }
+  const expected = new Set(traces.map((trace) => trace.event.id));
+  if (expected.size !== traces.length) {
+    throw new Error("Raindrop portable evaluator input trace ids must be unique");
+  }
+  const returned = /* @__PURE__ */ new Set();
+  for (const outcome of result.outcomes) {
+    if (!expected.has(outcome.traceId)) {
+      throw new Error(`Raindrop portable evaluator returned foreign trace ${outcome.traceId}`);
+    }
+    if (returned.has(outcome.traceId)) {
+      throw new Error(`Raindrop portable evaluator repeated trace ${outcome.traceId}`);
+    }
+    returned.add(outcome.traceId);
+    if (outcome.state !== "graded") continue;
+    const valid = artifact.evaluator.outputType === "boolean" ? "pass" in outcome : artifact.evaluator.outputType === "score" ? "score" in outcome : "value" in outcome;
+    if (!valid) {
+      throw new Error(
+        `Raindrop portable evaluator ${artifact.evaluator.slug} returned the wrong graded value`
+      );
+    }
+  }
+  const missing = [...expected].find((traceId) => !returned.has(traceId));
+  if (missing) throw new Error(`Raindrop portable evaluator omitted trace ${missing}`);
+}
+async function artifactDigest(artifact) {
+  var _a;
+  if (!((_a = globalThis.crypto) == null ? void 0 : _a.subtle)) {
+    throw new Error("Raindrop portable evaluator requires Web Crypto SHA-256 support");
+  }
+  const { sha256: _digest, ...unsigned } = artifact;
+  const encoded = new TextEncoder().encode(canonicalJson(unsigned));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", encoded);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(",")}}`;
+}
+
+export {
+  EvalScoreSchema,
+  defineDataset,
+  isEvalDataset,
+  BooleanThresholdSchema,
+  NumericThresholdSchema,
+  defineEvaluatorProgram,
+  defineLocalEvaluator,
+  defineEvalSuite,
+  isEvalSuiteDefinition,
+  evaluatorName,
+  evaluatorOutput,
+  validateEvaluatorOutput,
+  TraceSchema,
+  EvalDatasetCaseIdSchema,
+  CapturedTraceSnapshotSchema,
+  EvalCaseTracePairSchema,
+  projectWorkshopTrace,
+  projectCapturedEvent,
+  traceOutput,
+  traceToolCalls,
+  parsePortableEvalResult,
+  importPortableEvaluator,
+  evaluatePortableEvaluator,
+  verifyPortableEvalArtifact
+};