@wix/evalforge-types 0.65.0 → 0.67.0

package/build/index.mjs

@@ -797,11 +797,67 @@ var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
 });
 var UpdateTestScenarioInputSchema = CreateTestScenarioInputSchema.partial();
 
-// src/suite/test-suite.ts
+// src/scenario/batch-import.ts
 import { z as z24 } from "zod";
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var BatchAssertionLinkSchema = z24.union([
+  z24.string().min(1),
+  ScenarioAssertionLinkSchema
+]);
+var BatchScenarioEntrySchema = z24.object({
+  name: z24.string().min(1, "name: Required"),
+  description: z24.string().optional().default(""),
+  triggerPrompt: z24.string().min(10, "triggerPrompt: Must be at least 10 characters"),
+  templateId: z24.string().nullish(),
+  tags: z24.array(z24.string()).optional(),
+  assertionLinks: z24.array(BatchAssertionLinkSchema).optional()
+});
+var BatchImportPayloadSchema = z24.object({
+  scenarios: z24.array(BatchScenarioEntrySchema).min(1, "scenarios array must contain at least one entry").max(100, "Maximum 100 scenarios per upload")
+});
+var BATCH_IMPORT_LIMITS = {
+  MAX_SCENARIOS: 100,
+  MAX_PAYLOAD_BYTES: 1048576
+  // 1 MB
+};
+function classifyAssertionRef(ref) {
+  if (ref.startsWith("system:")) {
+    return { type: "system", value: ref };
+  }
+  if (UUID_REGEX.test(ref)) {
+    return { type: "uuid", value: ref };
+  }
+  return { type: "name", value: ref };
+}
+function normalizeBatchAssertionLink(link) {
+  if (typeof link === "string") {
+    return { assertionId: link };
+  }
+  return link;
+}
+var BatchResultItemSchema = z24.object({
+  index: z24.number(),
+  name: z24.string(),
+  status: z24.enum(["valid", "invalid"]),
+  id: z24.string().nullable().optional(),
+  errors: z24.array(z24.string()).optional()
+});
+var BatchSummarySchema = z24.object({
+  total: z24.number(),
+  valid: z24.number(),
+  invalid: z24.number(),
+  created: z24.number()
+});
+var BatchImportResponseSchema = z24.object({
+  summary: BatchSummarySchema,
+  results: z24.array(BatchResultItemSchema)
+});
+
+// src/suite/test-suite.ts
+import { z as z25 } from "zod";
 var TestSuiteSchema = TenantEntitySchema.extend({
   /** IDs of test scenarios in this suite */
-  scenarioIds: z24.array(z24.string())
+  scenarioIds: z25.array(z25.string())
 });
 var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
   id: true,
@@ -812,21 +868,21 @@ var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
 var UpdateTestSuiteInputSchema = CreateTestSuiteInputSchema.partial();
 
 // src/evaluation/metrics.ts
-import { z as z25 } from "zod";
-var TokenUsageSchema = z25.object({
-  prompt: z25.number(),
-  completion: z25.number(),
-  total: z25.number()
-});
-var EvalMetricsSchema = z25.object({
-  totalAssertions: z25.number(),
-  passed: z25.number(),
-  failed: z25.number(),
-  skipped: z25.number(),
-  errors: z25.number(),
-  passRate: z25.number(),
-  avgDuration: z25.number(),
-  totalDuration: z25.number()
+import { z as z26 } from "zod";
+var TokenUsageSchema = z26.object({
+  prompt: z26.number(),
+  completion: z26.number(),
+  total: z26.number()
+});
+var EvalMetricsSchema = z26.object({
+  totalAssertions: z26.number(),
+  passed: z26.number(),
+  failed: z26.number(),
+  skipped: z26.number(),
+  errors: z26.number(),
+  passRate: z26.number(),
+  avgDuration: z26.number(),
+  totalDuration: z26.number()
 });
 var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["PENDING"] = "pending";
@@ -836,7 +892,7 @@ var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["CANCELLED"] = "cancelled";
   return EvalStatus2;
 })(EvalStatus || {});
-var EvalStatusSchema = z25.enum(EvalStatus);
+var EvalStatusSchema = z26.enum(EvalStatus);
 var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["COMPLETION"] = "completion";
   LLMStepType2["TOOL_USE"] = "tool_use";
@@ -844,54 +900,54 @@ var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["THINKING"] = "thinking";
   return LLMStepType2;
 })(LLMStepType || {});
-var LLMTraceStepSchema = z25.object({
-  id: z25.string(),
-  stepNumber: z25.number(),
-  type: z25.enum(LLMStepType),
-  model: z25.string(),
-  provider: z25.string(),
-  startedAt: z25.string(),
-  durationMs: z25.number(),
+var LLMTraceStepSchema = z26.object({
+  id: z26.string(),
+  stepNumber: z26.number(),
+  type: z26.enum(LLMStepType),
+  model: z26.string(),
+  provider: z26.string(),
+  startedAt: z26.string(),
+  durationMs: z26.number(),
   tokenUsage: TokenUsageSchema,
-  costUsd: z25.number(),
-  toolName: z25.string().optional(),
-  toolArguments: z25.string().optional(),
-  inputPreview: z25.string().optional(),
-  outputPreview: z25.string().optional(),
-  success: z25.boolean(),
-  error: z25.string().optional(),
-  turnIndex: z25.number().optional()
-});
-var LLMBreakdownStatsSchema = z25.object({
-  count: z25.number(),
-  durationMs: z25.number(),
-  tokens: z25.number(),
-  costUsd: z25.number()
-});
-var LLMTraceSummarySchema = z25.object({
-  totalSteps: z25.number(),
-  totalTurns: z25.number().optional(),
-  totalDurationMs: z25.number(),
+  costUsd: z26.number(),
+  toolName: z26.string().optional(),
+  toolArguments: z26.string().optional(),
+  inputPreview: z26.string().optional(),
+  outputPreview: z26.string().optional(),
+  success: z26.boolean(),
+  error: z26.string().optional(),
+  turnIndex: z26.number().optional()
+});
+var LLMBreakdownStatsSchema = z26.object({
+  count: z26.number(),
+  durationMs: z26.number(),
+  tokens: z26.number(),
+  costUsd: z26.number()
+});
+var LLMTraceSummarySchema = z26.object({
+  totalSteps: z26.number(),
+  totalTurns: z26.number().optional(),
+  totalDurationMs: z26.number(),
   totalTokens: TokenUsageSchema,
-  totalCostUsd: z25.number(),
-  stepTypeBreakdown: z25.record(z25.string(), LLMBreakdownStatsSchema).optional(),
-  modelBreakdown: z25.record(z25.string(), LLMBreakdownStatsSchema),
-  modelsUsed: z25.array(z25.string())
-});
-var LLMTraceSchema = z25.object({
-  id: z25.string(),
-  steps: z25.array(LLMTraceStepSchema),
+  totalCostUsd: z26.number(),
+  stepTypeBreakdown: z26.record(z26.string(), LLMBreakdownStatsSchema).optional(),
+  modelBreakdown: z26.record(z26.string(), LLMBreakdownStatsSchema),
+  modelsUsed: z26.array(z26.string())
+});
+var LLMTraceSchema = z26.object({
+  id: z26.string(),
+  steps: z26.array(LLMTraceStepSchema),
   summary: LLMTraceSummarySchema
 });
 
 // src/evaluation/eval-result.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/evaluation/eval-run.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/evaluation/live-trace.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["THINKING"] = "thinking";
   LiveTraceEventType2["TOOL_USE"] = "tool_use";
@@ -905,37 +961,37 @@ var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["USER"] = "user";
   return LiveTraceEventType2;
 })(LiveTraceEventType || {});
-var LiveTraceEventSchema = z26.object({
+var LiveTraceEventSchema = z27.object({
   /** The evaluation run ID */
-  evalRunId: z26.string(),
+  evalRunId: z27.string(),
   /** The scenario ID being executed */
-  scenarioId: z26.string(),
+  scenarioId: z27.string(),
   /** The scenario name for display */
-  scenarioName: z26.string(),
+  scenarioName: z27.string(),
   /** The target ID (skill, agent, etc.) */
-  targetId: z26.string(),
+  targetId: z27.string(),
   /** The target name for display */
-  targetName: z26.string(),
+  targetName: z27.string(),
   /** Step number in the current scenario execution */
-  stepNumber: z26.number(),
+  stepNumber: z27.number(),
   /** Type of trace event */
-  type: z26.enum(LiveTraceEventType),
+  type: z27.enum(LiveTraceEventType),
   /** Tool name if this is a tool_use event */
-  toolName: z26.string().optional(),
+  toolName: z27.string().optional(),
   /** Tool arguments preview (truncated JSON) */
-  toolArgs: z26.string().optional(),
+  toolArgs: z27.string().optional(),
   /** Output preview (truncated text) */
-  outputPreview: z26.string().optional(),
+  outputPreview: z27.string().optional(),
   /** File path for file operations */
-  filePath: z26.string().optional(),
+  filePath: z27.string().optional(),
   /** Elapsed time in milliseconds for progress events */
-  elapsedMs: z26.number().optional(),
+  elapsedMs: z27.number().optional(),
   /** Thinking/reasoning text from Claude */
-  thinking: z26.string().optional(),
+  thinking: z27.string().optional(),
   /** Timestamp when this event occurred */
-  timestamp: z26.string(),
+  timestamp: z27.string(),
   /** Whether this is the final event for this scenario */
-  isComplete: z26.boolean()
+  isComplete: z27.boolean()
 });
 var TRACE_EVENT_PREFIX = "TRACE_EVENT:";
 function parseTraceEventLine(line) {
@@ -964,15 +1020,15 @@ var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
   TriggerType2["SCHEDULED"] = "SCHEDULED";
   return TriggerType2;
 })(TriggerType || {});
-var TriggerMetadataSchema = z27.object({
-  version: z27.string().optional(),
-  resourceUpdated: z27.array(z27.string()).optional(),
-  scheduleId: z27.string().optional()
+var TriggerMetadataSchema = z28.object({
+  version: z28.string().optional(),
+  resourceUpdated: z28.array(z28.string()).optional(),
+  scheduleId: z28.string().optional()
 });
-var TriggerSchema = z27.object({
-  id: z27.string(),
+var TriggerSchema = z28.object({
+  id: z28.string(),
   metadata: TriggerMetadataSchema.optional(),
-  type: z27.nativeEnum(TriggerType)
+  type: z28.nativeEnum(TriggerType)
 });
 var FailureCategory = /* @__PURE__ */ ((FailureCategory2) => {
   FailureCategory2["MISSING_FILE"] = "missing_file";
@@ -990,30 +1046,30 @@ var FailureSeverity = /* @__PURE__ */ ((FailureSeverity2) => {
   FailureSeverity2["LOW"] = "low";
   return FailureSeverity2;
 })(FailureSeverity || {});
-var DiffLineTypeSchema = z27.enum(["added", "removed", "unchanged"]);
-var DiffLineSchema = z27.object({
+var DiffLineTypeSchema = z28.enum(["added", "removed", "unchanged"]);
+var DiffLineSchema = z28.object({
   type: DiffLineTypeSchema,
-  content: z27.string(),
-  lineNumber: z27.number()
-});
-var DiffContentSchema = z27.object({
-  path: z27.string(),
-  expected: z27.string(),
-  actual: z27.string(),
-  diffLines: z27.array(DiffLineSchema),
-  renamedFrom: z27.string().optional(),
+  content: z28.string(),
+  lineNumber: z28.number()
+});
+var DiffContentSchema = z28.object({
+  path: z28.string(),
+  expected: z28.string(),
+  actual: z28.string(),
+  diffLines: z28.array(DiffLineSchema),
+  renamedFrom: z28.string().optional(),
   /** Whether this file is an infrastructure/config file (e.g. .claude/settings.json, .mcp.json) */
-  isInfrastructure: z27.boolean().optional()
+  isInfrastructure: z28.boolean().optional()
 });
-var CommandExecutionSchema = z27.object({
-  command: z27.string(),
-  exitCode: z27.number(),
-  output: z27.string().optional(),
-  duration: z27.number()
+var CommandExecutionSchema = z28.object({
+  command: z28.string(),
+  exitCode: z28.number(),
+  output: z28.string().optional(),
+  duration: z28.number()
 });
-var FileModificationSchema = z27.object({
-  path: z27.string(),
-  action: z27.enum(["created", "modified", "deleted"])
+var FileModificationSchema = z28.object({
+  path: z28.string(),
+  action: z28.enum(["created", "modified", "deleted"])
 });
 var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["NEW"] = "new";
@@ -1021,89 +1077,91 @@ var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["UNCHANGED"] = "unchanged";
   return TemplateFileStatus2;
 })(TemplateFileStatus || {});
-var TemplateFileSchema = z27.object({
+var TemplateFileSchema = z28.object({
   /** Relative path within the template */
-  path: z27.string(),
+  path: z28.string(),
   /** Full file content after execution */
-  content: z27.string(),
+  content: z28.string(),
   /** File status (new, modified, unchanged) */
-  status: z27.enum(["new", "modified", "unchanged"]),
+  status: z28.enum(["new", "modified", "unchanged"]),
   /** Whether this file is an infrastructure/config file (e.g. .claude/settings.json, .mcp.json) */
-  isInfrastructure: z27.boolean().optional()
-});
-var ApiCallSchema = z27.object({
-  endpoint: z27.string(),
-  tokensUsed: z27.number(),
-  duration: z27.number()
-});
-var ExecutionTraceSchema = z27.object({
-  commands: z27.array(CommandExecutionSchema),
-  filesModified: z27.array(FileModificationSchema),
-  apiCalls: z27.array(ApiCallSchema),
-  totalDuration: z27.number()
-});
-var FailureAnalysisSchema = z27.object({
-  category: z27.enum(FailureCategory),
-  severity: z27.enum(FailureSeverity),
-  summary: z27.string(),
-  details: z27.string(),
-  rootCause: z27.string(),
-  suggestedFix: z27.string(),
-  relatedAssertions: z27.array(z27.string()),
-  codeSnippet: z27.string().optional(),
-  similarIssues: z27.array(z27.string()).optional(),
-  patternId: z27.string().optional(),
+  isInfrastructure: z28.boolean().optional()
+});
+var ApiCallSchema = z28.object({
+  endpoint: z28.string(),
+  tokensUsed: z28.number(),
+  duration: z28.number()
+});
+var ExecutionTraceSchema = z28.object({
+  commands: z28.array(CommandExecutionSchema),
+  filesModified: z28.array(FileModificationSchema),
+  apiCalls: z28.array(ApiCallSchema),
+  totalDuration: z28.number()
+});
+var FailureAnalysisSchema = z28.object({
+  category: z28.enum(FailureCategory),
+  severity: z28.enum(FailureSeverity),
+  summary: z28.string(),
+  details: z28.string(),
+  rootCause: z28.string(),
+  suggestedFix: z28.string(),
+  relatedAssertions: z28.array(z28.string()),
+  codeSnippet: z28.string().optional(),
+  similarIssues: z28.array(z28.string()).optional(),
+  patternId: z28.string().optional(),
   // Extended fields for detailed debugging
   diff: DiffContentSchema.optional(),
   executionTrace: ExecutionTraceSchema.optional()
 });
 var EvalRunSchema = TenantEntitySchema.extend({
   /** Agent ID for this run */
-  agentId: z27.string().optional(),
+  agentId: z28.string().optional(),
   /** Preset ID that originated this run (optional) */
-  presetId: z27.string().optional(),
+  presetId: z28.string().optional(),
   /** Skill IDs for this run */
-  skillIds: z27.array(z27.string()).optional(),
+  skillIds: z28.array(z28.string()).optional(),
   /** Map of skillId to skillVersionId for this run */
-  skillVersions: z27.record(z27.string(), z27.string()).optional(),
+  skillVersions: z28.record(z28.string(), z28.string()).optional(),
   /** Scenario IDs to run (always present — resolved server-side from tags when needed) */
-  scenarioIds: z27.array(z27.string()),
+  scenarioIds: z28.array(z28.string()),
   /** Current status */
   status: EvalStatusSchema,
   /** Progress percentage (0-100) */
-  progress: z27.number(),
+  progress: z28.number(),
   /** Results for each scenario/target combination (lazy to break eval-result ↔ eval-run cycle) */
-  results: z27.array(z27.lazy(() => EvalRunResultSchema)),
+  results: z28.array(z28.lazy(() => EvalRunResultSchema)),
   /** Aggregated metrics across all results */
   aggregateMetrics: EvalMetricsSchema,
   /** Failure analyses */
-  failureAnalyses: z27.array(FailureAnalysisSchema).optional(),
+  failureAnalyses: z28.array(FailureAnalysisSchema).optional(),
   /** Aggregated LLM trace summary */
   llmTraceSummary: LLMTraceSummarySchema.optional(),
   /** What triggered this run */
   trigger: TriggerSchema.optional(),
   /** When the run started (set when evaluation is triggered) */
-  startedAt: z27.string().optional(),
+  startedAt: z28.string().optional(),
   /** When the run completed */
-  completedAt: z27.string().optional(),
+  completedAt: z28.string().optional(),
   /** Live trace events captured during execution (for playback on results page) */
-  liveTraceEvents: z27.array(LiveTraceEventSchema).optional(),
+  liveTraceEvents: z28.array(LiveTraceEventSchema).optional(),
   /** Remote job ID for tracking execution in Dev Machines */
-  jobId: z27.string().optional(),
+  jobId: z28.string().optional(),
   /** Remote job status from the Dev Machine API (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED) */
-  jobStatus: z27.string().optional(),
+  jobStatus: z28.string().optional(),
   /** Remote job error message if the job failed */
-  jobError: z27.string().optional(),
+  jobError: z28.string().optional(),
   /** Timestamp of the last job status check */
-  jobStatusCheckedAt: z27.string().optional(),
+  jobStatusCheckedAt: z28.string().optional(),
   /** MCP server IDs to enable for this run (optional) */
-  mcpIds: z27.array(z27.string()).optional(),
+  mcpIds: z28.array(z28.string()).optional(),
   /** Sub-agent IDs to enable for this run (optional) */
-  subAgentIds: z27.array(z27.string()).optional(),
+  subAgentIds: z28.array(z28.string()).optional(),
   /** Rule IDs to enable for this run (optional) */
-  ruleIds: z27.array(z27.string()).optional(),
+  ruleIds: z28.array(z28.string()).optional(),
   /** Tags used to select scenarios for this run (for traceability) */
-  tags: z27.array(z27.string()).optional()
+  tags: z28.array(z28.string()).optional(),
+  /** How many times each scenario is executed within this eval run. Default: 1. Max: 20. */
+  runsPerScenario: z28.number().int().min(1).max(20).optional()
 });
 var CreateEvalRunInputSchema = EvalRunSchema.omit({
   id: true,
@@ -1118,60 +1176,60 @@ var CreateEvalRunInputSchema = EvalRunSchema.omit({
   scenarioIds: true
 }).extend({
   /** Optional on input — backend resolves from tags when not provided */
-  scenarioIds: z27.array(z27.string()).optional()
+  scenarioIds: z28.array(z28.string()).optional()
 }).refine(
   (data) => data.scenarioIds && data.scenarioIds.length > 0 || data.tags && data.tags.length > 0,
   { message: "Either scenarioIds or tags must be provided" }
 );
-var EvaluationProgressSchema = z27.object({
-  runId: z27.string(),
-  targetId: z27.string(),
-  totalScenarios: z27.number(),
-  completedScenarios: z27.number(),
-  scenarioProgress: z27.array(
-    z27.object({
-      scenarioId: z27.string(),
-      currentStep: z27.string(),
-      error: z27.string().optional()
+var EvaluationProgressSchema = z28.object({
+  runId: z28.string(),
+  targetId: z28.string(),
+  totalScenarios: z28.number(),
+  completedScenarios: z28.number(),
+  scenarioProgress: z28.array(
+    z28.object({
+      scenarioId: z28.string(),
+      currentStep: z28.string(),
+      error: z28.string().optional()
     })
   ),
-  createdAt: z27.number()
-});
-var EvaluationLogSchema = z27.object({
-  runId: z27.string(),
-  scenarioId: z27.string(),
-  log: z27.object({
-    level: z27.enum(["info", "error", "debug"]),
-    message: z27.string().optional(),
-    args: z27.array(z27.any()).optional(),
-    error: z27.string().optional()
+  createdAt: z28.number()
+});
+var EvaluationLogSchema = z28.object({
+  runId: z28.string(),
+  scenarioId: z28.string(),
+  log: z28.object({
+    level: z28.enum(["info", "error", "debug"]),
+    message: z28.string().optional(),
+    args: z28.array(z28.any()).optional(),
+    error: z28.string().optional()
   })
 });
 var LLM_TIMEOUT = 12e4;
 
 // src/evaluation/conversation.ts
-import { z as z28 } from "zod";
-var TextBlockSchema = z28.object({
-  type: z28.literal("text"),
-  text: z28.string()
-});
-var ThinkingBlockSchema = z28.object({
-  type: z28.literal("thinking"),
-  thinking: z28.string()
-});
-var ToolUseBlockSchema = z28.object({
-  type: z28.literal("tool_use"),
-  toolName: z28.string(),
-  toolId: z28.string(),
-  input: z28.unknown()
-});
-var ToolResultBlockSchema = z28.object({
-  type: z28.literal("tool_result"),
-  toolUseId: z28.string(),
-  content: z28.string(),
-  isError: z28.boolean().optional()
-});
-var ConversationBlockSchema = z28.discriminatedUnion("type", [
+import { z as z29 } from "zod";
+var TextBlockSchema = z29.object({
+  type: z29.literal("text"),
+  text: z29.string()
+});
+var ThinkingBlockSchema = z29.object({
+  type: z29.literal("thinking"),
+  thinking: z29.string()
+});
+var ToolUseBlockSchema = z29.object({
+  type: z29.literal("tool_use"),
+  toolName: z29.string(),
+  toolId: z29.string(),
+  input: z29.unknown()
+});
+var ToolResultBlockSchema = z29.object({
+  type: z29.literal("tool_result"),
+  toolUseId: z29.string(),
+  content: z29.string(),
+  isError: z29.boolean().optional()
+});
+var ConversationBlockSchema = z29.discriminatedUnion("type", [
   TextBlockSchema,
   ThinkingBlockSchema,
   ToolUseBlockSchema,
@@ -1182,18 +1240,18 @@ var ConversationMessageRoles = [
   "user",
   "system"
 ];
-var ConversationMessageSchema = z28.object({
-  role: z28.enum(ConversationMessageRoles),
-  content: z28.array(ConversationBlockSchema),
-  timestamp: z28.string()
+var ConversationMessageSchema = z29.object({
+  role: z29.enum(ConversationMessageRoles),
+  content: z29.array(ConversationBlockSchema),
+  timestamp: z29.string()
 });
-var ScenarioConversationSchema = z28.object({
-  id: z28.string(),
-  projectId: z28.string(),
-  evalRunId: z28.string(),
-  resultId: z28.string(),
-  messages: z28.array(ConversationMessageSchema),
-  createdAt: z28.string()
+var ScenarioConversationSchema = z29.object({
+  id: z29.string(),
+  projectId: z29.string(),
+  evalRunId: z29.string(),
+  resultId: z29.string(),
+  messages: z29.array(ConversationMessageSchema),
+  createdAt: z29.string()
 });
 
 // src/evaluation/eval-result.ts
@@ -1204,94 +1262,96 @@ var AssertionResultStatus = /* @__PURE__ */ ((AssertionResultStatus2) => {
   AssertionResultStatus2["ERROR"] = "error";
   return AssertionResultStatus2;
 })(AssertionResultStatus || {});
-var AssertionResultSchema = z29.object({
-  id: z29.string(),
-  assertionId: z29.string(),
-  assertionType: z29.string(),
-  assertionName: z29.string(),
-  status: z29.enum(AssertionResultStatus),
-  message: z29.string().optional(),
-  expected: z29.string().optional(),
-  actual: z29.string().optional(),
-  duration: z29.number().optional(),
-  details: z29.record(z29.string(), z29.unknown()).optional(),
-  llmTraceSteps: z29.array(LLMTraceStepSchema).optional()
-});
-var EvalRunResultSchema = z29.object({
-  id: z29.string(),
-  targetId: z29.string(),
-  targetName: z29.string().optional(),
+var AssertionResultSchema = z30.object({
+  id: z30.string(),
+  assertionId: z30.string(),
+  assertionType: z30.string(),
+  assertionName: z30.string(),
+  status: z30.enum(AssertionResultStatus),
+  message: z30.string().optional(),
+  expected: z30.string().optional(),
+  actual: z30.string().optional(),
+  duration: z30.number().optional(),
+  details: z30.record(z30.string(), z30.unknown()).optional(),
+  llmTraceSteps: z30.array(LLMTraceStepSchema).optional()
+});
+var EvalRunResultSchema = z30.object({
+  id: z30.string(),
+  targetId: z30.string(),
+  targetName: z30.string().optional(),
   /** SkillVersion ID used for this evaluation (for version tracking) */
-  skillVersionId: z29.string().optional(),
+  skillVersionId: z30.string().optional(),
   /** SkillVersion semver string (e.g., "1.0.0", "1.2.3") for display */
-  skillVersion: z29.string().optional(),
-  scenarioId: z29.string(),
-  scenarioName: z29.string(),
+  skillVersion: z30.string().optional(),
+  scenarioId: z30.string(),
+  scenarioName: z30.string(),
   modelConfig: ModelConfigSchema.optional(),
-  assertionResults: z29.array(AssertionResultSchema),
+  assertionResults: z30.array(AssertionResultSchema),
   metrics: EvalMetricsSchema.optional(),
-  passed: z29.number(),
-  failed: z29.number(),
-  passRate: z29.number(),
-  duration: z29.number(),
-  outputText: z29.string().optional(),
-  files: z29.array(ExpectedFileSchema).optional(),
-  fileDiffs: z29.array(DiffContentSchema).optional(),
+  passed: z30.number(),
+  failed: z30.number(),
+  passRate: z30.number(),
+  duration: z30.number(),
+  outputText: z30.string().optional(),
+  files: z30.array(ExpectedFileSchema).optional(),
+  fileDiffs: z30.array(DiffContentSchema).optional(),
   /** Full template files after execution with status indicators */
-  templateFiles: z29.array(TemplateFileSchema).optional(),
-  startedAt: z29.string().optional(),
-  completedAt: z29.string().optional(),
+  templateFiles: z30.array(TemplateFileSchema).optional(),
+  startedAt: z30.string().optional(),
+  completedAt: z30.string().optional(),
   llmTrace: LLMTraceSchema.optional(),
   /** Full conversation messages (only present in transit; stripped before DB storage) */
-  conversation: z29.array(ConversationMessageSchema).optional()
-});
-var PromptResultSchema = z29.object({
-  text: z29.string(),
-  files: z29.array(z29.unknown()).optional(),
-  finishReason: z29.string().optional(),
-  reasoning: z29.string().optional(),
-  reasoningDetails: z29.unknown().optional(),
-  toolCalls: z29.array(z29.unknown()).optional(),
-  toolResults: z29.array(z29.unknown()).optional(),
-  warnings: z29.array(z29.unknown()).optional(),
-  sources: z29.array(z29.unknown()).optional(),
-  steps: z29.array(z29.unknown()),
-  generationTimeMs: z29.number(),
-  prompt: z29.string(),
-  systemPrompt: z29.string(),
-  usage: z29.object({
-    totalTokens: z29.number().optional(),
-    totalMicrocentsSpent: z29.number().optional()
+  conversation: z30.array(ConversationMessageSchema).optional(),
+  /** 0-based iteration index when a scenario is run multiple times within a single eval run */
+  iterationIndex: z30.number().int().min(0).optional()
+});
+var PromptResultSchema = z30.object({
+  text: z30.string(),
+  files: z30.array(z30.unknown()).optional(),
+  finishReason: z30.string().optional(),
+  reasoning: z30.string().optional(),
+  reasoningDetails: z30.unknown().optional(),
+  toolCalls: z30.array(z30.unknown()).optional(),
+  toolResults: z30.array(z30.unknown()).optional(),
+  warnings: z30.array(z30.unknown()).optional(),
+  sources: z30.array(z30.unknown()).optional(),
+  steps: z30.array(z30.unknown()),
+  generationTimeMs: z30.number(),
+  prompt: z30.string(),
+  systemPrompt: z30.string(),
+  usage: z30.object({
+    totalTokens: z30.number().optional(),
+    totalMicrocentsSpent: z30.number().optional()
   })
 });
-var EvaluationResultSchema = z29.object({
-  id: z29.string(),
-  runId: z29.string(),
-  timestamp: z29.number(),
+var EvaluationResultSchema = z30.object({
+  id: z30.string(),
+  runId: z30.string(),
+  timestamp: z30.number(),
   promptResult: PromptResultSchema,
-  testResults: z29.array(z29.unknown()),
-  tags: z29.array(z29.string()).optional(),
-  feedback: z29.string().optional(),
-  score: z29.number(),
-  suiteId: z29.string().optional()
-});
-var LeanEvaluationResultSchema = z29.object({
-  id: z29.string(),
-  runId: z29.string(),
-  timestamp: z29.number(),
-  tags: z29.array(z29.string()).optional(),
-  scenarioId: z29.string(),
-  scenarioVersion: z29.number().optional(),
-  targetId: z29.string(),
-  targetVersion: z29.number().optional(),
-  suiteId: z29.string().optional(),
-  score: z29.number(),
-  time: z29.number().optional(),
-  microcentsSpent: z29.number().optional()
+  testResults: z30.array(z30.unknown()),
+  tags: z30.array(z30.string()).optional(),
+  feedback: z30.string().optional(),
+  score: z30.number(),
+  suiteId: z30.string().optional()
+});
+var LeanEvaluationResultSchema = z30.object({
+  id: z30.string(),
+  runId: z30.string(),
+  timestamp: z30.number(),
+  tags: z30.array(z30.string()).optional(),
+  scenarioId: z30.string(),
+  scenarioVersion: z30.number().optional(),
+  targetId: z30.string(),
+  targetVersion: z30.number().optional(),
+  suiteId: z30.string().optional(),
+  score: z30.number(),
+  time: z30.number().optional(),
+  microcentsSpent: z30.number().optional()
 });
 
 // src/evaluation/eval-run-folder.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var EvalRunFolderSchema = TenantEntitySchema.extend({});
 var CreateEvalRunFolderInputSchema = EvalRunFolderSchema.omit({
   id: true,
@@ -1305,26 +1365,26 @@ var UpdateEvalRunFolderInputSchema = EvalRunFolderSchema.omit({
   updatedAt: true,
   deleted: true
 }).partial();
-var EvalRunFolderMembershipSchema = z30.object({
-  folderId: z30.string(),
-  evalRunId: z30.string(),
-  projectId: z30.string(),
-  createdAt: z30.string()
+var EvalRunFolderMembershipSchema = z31.object({
+  folderId: z31.string(),
+  evalRunId: z31.string(),
+  projectId: z31.string(),
+  createdAt: z31.string()
 });
 
 // src/project/project.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var ProjectSchema = BaseEntitySchema.extend({
-  appId: z31.string().optional().describe("The ID of the app in Dev Center"),
-  scenarioTags: z31.array(z31.string()).optional().describe("Project-level tag vocabulary for scenarios"),
+  appId: z32.string().optional().describe("The ID of the app in Dev Center"),
+  scenarioTags: z32.array(z32.string()).optional().describe("Project-level tag vocabulary for scenarios"),
   /** Per-project Wix auth token (write-only — never returned in GET responses). null = clear. */
-  wixAuthToken: z31.string().nullable().optional().describe("Wix auth token for CLI/MCP authentication (encrypted at rest)"),
+  wixAuthToken: z32.string().nullable().optional().describe("Wix auth token for CLI/MCP authentication (encrypted at rest)"),
   /** Per-project Base44 auth file content (write-only — never returned in GET responses). null = clear. */
-  base44AuthFile: z31.string().nullable().optional().describe("Base64-encoded Base44 auth file content (encrypted at rest)"),
+  base44AuthFile: z32.string().nullable().optional().describe("Base64-encoded Base44 auth file content (encrypted at rest)"),
   /** Resolved at runtime from the encrypted Wix auth token */
-  wixAuthEmail: z31.string().optional().describe("Email associated with the Wix auth token (resolved at runtime)"),
+  wixAuthEmail: z32.string().optional().describe("Email associated with the Wix auth token (resolved at runtime)"),
   /** Resolved at runtime from the encrypted Base44 auth file */
-  base44AuthEmail: z31.string().optional().describe("Email from the Base44 auth file (resolved at runtime)")
+  base44AuthEmail: z32.string().optional().describe("Email from the Base44 auth file (resolved at runtime)")
 });
 var CreateProjectInputSchema = ProjectSchema.omit({
   id: true,
@@ -1350,7 +1410,7 @@ var CreateTemplateInputSchema = TemplateSchema.omit({
 var UpdateTemplateInputSchema = CreateTemplateInputSchema.partial();
 
 // src/schedule/eval-schedule.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var FrequencyType = /* @__PURE__ */ ((FrequencyType2) => {
   FrequencyType2["DAILY"] = "daily";
   FrequencyType2["WEEKDAY"] = "weekday";
@@ -1360,29 +1420,29 @@ var FrequencyType = /* @__PURE__ */ ((FrequencyType2) => {
 })(FrequencyType || {});
 var EvalScheduleSchema = TenantEntitySchema.extend({
   /** Whether the schedule is active */
-  enabled: z32.boolean(),
+  enabled: z33.boolean(),
   /** Test suite to run */
-  suiteId: z32.string(),
+  suiteId: z33.string(),
   /** Preset that provides agent + entities for this schedule */
-  presetId: z32.string(),
+  presetId: z33.string(),
   /** How often to run */
-  frequencyType: z32.nativeEnum(FrequencyType),
+  frequencyType: z33.nativeEnum(FrequencyType),
   /** Time of day in 24h format (HH:MM), hours 00-23, minutes 00-59 */
-  timeOfDay: z32.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+  timeOfDay: z33.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
   /** Day of week (0=Sun, 6=Sat) for weekly schedules */
-  dayOfWeek: z32.number().min(0).max(6).optional(),
+  dayOfWeek: z33.number().min(0).max(6).optional(),
   /** Day of month (1-31) for monthly schedules */
-  dayOfMonth: z32.number().min(1).max(31).optional(),
+  dayOfMonth: z33.number().min(1).max(31).optional(),
   /** IANA timezone (e.g., 'America/New_York') */
-  timezone: z32.string(),
+  timezone: z33.string(),
   /** ID of the last eval run created by this schedule */
-  lastRunId: z32.string().optional(),
+  lastRunId: z33.string().optional(),
   /** Denormalized status of the last run */
-  lastRunStatus: z32.string().optional(),
+  lastRunStatus: z33.string().optional(),
   /** ISO timestamp of the last run */
-  lastRunAt: z32.string().optional(),
+  lastRunAt: z33.string().optional(),
   /** Next scheduled run time in UTC (pre-computed for efficient querying, set by backend) */
-  nextRunAt: z32.string().optional()
+  nextRunAt: z33.string().optional()
 });
 function isValidTimezone(tz) {
   try {
@@ -1395,14 +1455,14 @@ function isValidTimezone(tz) {
 function validateScheduleFields(data, ctx, options) {
   if (data.frequencyType === "weekly" /* WEEKLY */ && data.dayOfWeek == null) {
     ctx.addIssue({
-      code: z32.ZodIssueCode.custom,
+      code: z33.ZodIssueCode.custom,
       message: "dayOfWeek is required for weekly schedules",
       path: ["dayOfWeek"]
     });
   }
   if (data.frequencyType === "monthly" /* MONTHLY */ && data.dayOfMonth == null) {
     ctx.addIssue({
-      code: z32.ZodIssueCode.custom,
+      code: z33.ZodIssueCode.custom,
       message: "dayOfMonth is required for monthly schedules",
       path: ["dayOfMonth"]
     });
@@ -1410,7 +1470,7 @@ function validateScheduleFields(data, ctx, options) {
   const shouldValidateTz = options.partial ? data.timezone !== void 0 : true;
   if (shouldValidateTz && !isValidTimezone(data.timezone)) {
     ctx.addIssue({
-      code: z32.ZodIssueCode.custom,
+      code: z33.ZodIssueCode.custom,
       message: "Invalid IANA timezone",
       path: ["timezone"]
     });
@@ -1677,8 +1737,15 @@ export {
   AssertionResultStatus,
   AssertionSchema,
   AssertionTypeSchema,
+  BATCH_IMPORT_LIMITS,
   BaseEntitySchema,
   BaseTestSchema,
+  BatchAssertionLinkSchema,
+  BatchImportPayloadSchema,
+  BatchImportResponseSchema,
+  BatchResultItemSchema,
+  BatchScenarioEntrySchema,
+  BatchSummarySchema,
   BuildCheckTestSchema,
   BuildPassedAssertionSchema,
   BuildPassedConfigSchema,
@@ -1821,11 +1888,13 @@ export {
   UpdateTestScenarioInputSchema,
   UpdateTestSuiteInputSchema,
   VitestTestSchema,
+  classifyAssertionRef,
   formatTraceEventLine,
   getSystemAssertion,
   getSystemAssertions,
   isSystemAssertionId,
   isValidSkillFolderName,
+  normalizeBatchAssertionLink,
   normalizeModelId,
   parseTraceEventLine,
   validateAssertionConfig