openpond-sdk 0.9.2 → 0.9.4

package/README.md

@@ -14,6 +14,30 @@ npm install openpond-sdk
 
 Node.js 22.14 or newer is required. This package is server-only: never expose an OpenPond API key in browser code or a `NEXT_PUBLIC_*` environment variable.
 
+## Saved Experiments
+
+`OpenPondExperimentsClient` from `openpond-sdk/experiments` saves immutable named
+configuration revisions and starts separate executions. It is also available as
+`createOpenPondClient({ apiKey, baseUrl }).experiments(teamId)`. Saving does not
+start compute. Supply stable operation IDs for save and Start, and reuse them
+after transport failures. A new Start operation creates another execution from
+the exact definition reference; configuration updates require `expectedRevision`.
+
+`get` and `list` read saved configurations; `result` reads portable retained
+execution evidence. `compare` verifies both retained results and uses the shared
+Evals compatibility and score-eligibility rules without starting or regrading
+anything. Execution status and cancellation use `OpenPondModelTasksetRunsClient`.
+Host runtime readiness, permissions and whole-execution budgets remain enforced
+on Start. Unsupported runtime configurations fail admission before dispatch.
+
+Released Profile, Workflow, Skill and Agent-action targets use the
+`hosted_harness` policy with an exact `profileRepositoryId`, native `source`,
+`packageHash` and `modelConfigurationHash`. The host resolves these pins through
+the authorized native runtime; callers cannot replace released behavior with
+Chat messages. Native receipt IDs belong to each execution, while the saved
+definition retains the same task/seed population. Clients verify repository,
+source, package, model and case identities before accepting a run.
+
 ## Next.js route handler
 
 Sandbox and model configuration are independently optional. With only `apiKey`,

package/dist/chunk-62LWLACP.js

@@ -0,0 +1,155 @@
+import {
+  EvaluationProjectContextSchema,
+  ModelStarterAttemptPolicySchema,
+  ModelStarterAttemptSummarySchema
+} from "./chunk-XR6CLSCS.js";
+import {
+  ModelProjectVersionedRefSchema,
+  canonicalJson,
+  canonicalSha256
+} from "./chunk-TCHAWJMB.js";
+import {
+  assertContentHash,
+  contentHash
+} from "./chunk-QUOW6URQ.js";
+
+// src/harness-experiment-policy.ts
+import { z } from "zod";
+import { ProfileEvaluationRunSourceSchema } from "@openpond/evals";
+var Id = z.string().trim().min(1).max(240);
+var Hash = z.string().regex(/^[a-f0-9]{64}$/);
+var HarnessExperimentPolicySchema = z.object({
+  kind: z.literal("hosted_harness"),
+  modelId: Id,
+  reasoningEffort: z.enum(["off", "low", "medium", "high", "xhigh", "max"]).optional(),
+  profileRepositoryId: Id,
+  source: ProfileEvaluationRunSourceSchema,
+  modelConfigurationHash: Hash,
+  packageHash: Hash
+}).strict();
+
+// src/model-taskset-runs-contracts.ts
+import { z as z2 } from "zod";
+import { TasksetRunManifestSchema, TasksetRunMemberSchema, TasksetMetricResultSchema, assertTasksetMetricResult, orderTasksetRunReceipts } from "@openpond/evals/metrics";
+import { AttemptReceiptSchema } from "@openpond/evals/runs";
+var IdSchema = z2.string().trim().min(1).max(200);
+var HashSchema = z2.string().regex(/^[a-f0-9]{64}$/);
+var ModelTasksetRunPolicySchema = z2.discriminatedUnion("kind", [
+  ModelStarterAttemptPolicySchema.options[0],
+  z2.object({ kind: z2.literal("fixture") }).strict(),
+  HarnessExperimentPolicySchema
+]);
+var ModelTasksetRunRequestSchema = z2.object({
+  schemaVersion: z2.literal("openpond.modelTasksetRunRequest.v1"),
+  operationId: IdSchema,
+  teamId: IdSchema,
+  modelProjectId: IdSchema.nullable(),
+  name: z2.string().trim().min(1).max(200).optional(),
+  project: EvaluationProjectContextSchema.optional(),
+  taskset: ModelProjectVersionedRefSchema,
+  policy: ModelTasksetRunPolicySchema,
+  population: z2.array(TasksetRunMemberSchema).min(1).max(1e4)
+}).strict().superRefine((value, context) => {
+  if (new Set(value.population.map((member) => member.receiptId)).size !== value.population.length) context.addIssue({ code: "custom", path: ["population"], message: "Run receipt identities must be unique." });
+  if (value.population.some((member) => member.fixtureId !== null !== (value.policy.kind === "fixture"))) context.addIssue({ code: "custom", path: ["population"], message: "Only fixture runs require a fixture identity for every member." });
+  if (value.population.some((member) => !/^(0|[1-9][0-9]*)$/.test(member.seed) || Number(member.seed) > 2147483647)) context.addIssue({ code: "custom", path: ["population"], message: "Hosted environment seeds must be integers from 0 to 2147483647." });
+  if (value.policy.kind === "hosted_harness" && value.modelProjectId !== null)
+    context.addIssue({ code: "custom", path: ["modelProjectId"], message: "A Harness target retains its released Profile binding separately from Model artifacts." });
+  if (value.policy.kind === "hosted_harness" && new Set(value.population.map((member) => canonicalJson([member.taskId, member.seed]))).size !== value.population.length)
+    context.addIssue({ code: "custom", path: ["population"], message: "Harness case identities must be unique for each task and seed." });
+});
+var ModelTasksetRunSummarySchema = z2.object({
+  schemaVersion: z2.literal("openpond.modelTasksetRunSummary.v1"),
+  id: IdSchema,
+  revision: z2.number().int().positive(),
+  teamId: IdSchema,
+  modelProjectId: IdSchema.nullable(),
+  name: z2.string().trim().min(1).max(200).optional(),
+  project: EvaluationProjectContextSchema.optional(),
+  operationId: IdSchema,
+  taskset: ModelProjectVersionedRefSchema,
+  policyKind: z2.enum(["hosted_chat", "fixture", "hosted_harness"]),
+  manifestHash: HashSchema,
+  status: z2.enum(["queued", "running", "cancelling", "completed", "failed", "cancelled"]),
+  totalCount: z2.number().int().min(1).max(1e4),
+  counts: z2.object({ pending: z2.number().int().nonnegative(), running: z2.number().int().nonnegative(), completed: z2.number().int().nonnegative(), failed: z2.number().int().nonnegative(), cancelled: z2.number().int().nonnegative() }).strict(),
+  createdAt: z2.iso.datetime(),
+  startedAt: z2.iso.datetime().nullable(),
+  completedAt: z2.iso.datetime().nullable(),
+  cleanupComplete: z2.boolean(),
+  resultAvailable: z2.boolean(),
+  score: z2.number().min(0).max(1).nullable(),
+  metricName: z2.string().min(1).max(240),
+  error: z2.object({ code: IdSchema, message: z2.string().max(2e3) }).strict().nullable()
+}).strict().superRefine((value, context) => {
+  if (Object.values(value.counts).reduce((sum, count) => sum + count, 0) !== value.totalCount) context.addIssue({ code: "custom", path: ["counts"], message: "Run counts must account for the complete population." });
+  if (value.status !== "completed" && value.score !== null) context.addIssue({ code: "custom", path: ["score"], message: "Only completed evaluations publish a metric value." });
+  if (["completed", "failed", "cancelled"].includes(value.status) && (!value.completedAt || value.counts.pending || value.counts.running)) context.addIssue({ code: "custom", message: "Terminal runs require complete population accounting." });
+  if (value.status === "cancelled" && !value.cleanupComplete) context.addIssue({ code: "custom", message: "Cancelled runs require confirmed cleanup." });
+  if (value.resultAvailable && !["completed", "failed", "cancelled"].includes(value.status)) context.addIssue({ code: "custom", message: "Run results require terminal population accounting." });
+  if (value.status === "completed" && (!value.cleanupComplete || !value.resultAvailable)) context.addIssue({ code: "custom", message: "Completed evaluations require retained results and confirmed cleanup." });
+});
+var ModelTasksetRunDetailsSchema = z2.object({
+  summary: ModelTasksetRunSummarySchema,
+  request: ModelTasksetRunRequestSchema,
+  manifest: TasksetRunManifestSchema,
+  policySnapshot: ModelStarterAttemptSummarySchema.shape.policySnapshot
+}).strict();
+var ModelTasksetRunListQuerySchema = z2.object({ modelProjectId: IdSchema.optional(), projectId: EvaluationProjectContextSchema.shape.id.optional(), afterId: IdSchema.optional(), limit: z2.number().int().min(1).max(100).default(25) }).strict();
+var ModelTasksetRunPageSchema = z2.object({ items: z2.array(ModelTasksetRunSummarySchema).max(100), nextCursor: IdSchema.nullable() }).strict();
+var ModelTasksetRunResultSchema = z2.object({
+  schemaVersion: z2.literal("openpond.modelTasksetRunResult.v1"),
+  run: ModelTasksetRunDetailsSchema,
+  receipts: z2.array(AttemptReceiptSchema).min(1).max(1e4),
+  metric: TasksetMetricResultSchema.nullable(),
+  contentHash: HashSchema
+}).strict();
+function verifyHarnessExperimentManifest(request, manifest) {
+  assertContentHash(manifest, "Taskset run manifest");
+  const policy = request.policy;
+  if (policy.kind !== "hosted_harness" || manifest.execution.kind !== "harness" || canonicalJson(manifest.profileEvaluation) !== canonicalJson(policy.source) || canonicalJson(manifest.execution.harnessRelease) !== canonicalJson(policy.source.harnessRelease) || manifest.metadata.profileRepositoryId !== policy.profileRepositoryId || manifest.packageHash !== policy.packageHash || manifest.policy.kind !== "model" || manifest.policy.model.provider !== "openpond" || manifest.policy.model.model !== policy.modelId || manifest.policy.model.revision !== null || manifest.policy.model.artifactHash !== null || manifest.policy.model.tokenizerRevision !== null || manifest.policy.model.chatTemplateHash !== null || manifest.policy.configurationHash !== policy.modelConfigurationHash || manifest.tasksetRelease.id !== request.taskset.id || manifest.tasksetRelease.contentHash !== request.taskset.contentHash || canonicalJson(manifest.population) !== canonicalJson(request.population) || manifest.population.some((member) => member.receiptId !== `evaluation-${contentHash([manifest.id, member.taskId, member.seed]).slice(0, 32)}`))
+    throw new Error("Harness evaluation differs from its admitted source, package or model configuration.");
+}
+async function verifyModelTasksetRunDetails(value) {
+  const result = ModelTasksetRunDetailsSchema.parse(value);
+  const { summary, request, manifest, policySnapshot } = result;
+  assertContentHash(manifest, "Taskset run manifest");
+  if (manifest.contentHash !== summary.manifestHash || manifest.id !== summary.id || manifest.createdAt !== summary.createdAt || summary.teamId !== request.teamId || summary.modelProjectId !== request.modelProjectId || canonicalJson(summary.project ?? null) !== canonicalJson(request.project ?? null) || canonicalJson(manifest.metadata.project ?? null) !== canonicalJson(request.project ?? null) || (summary.name ?? null) !== (request.name ?? null) || summary.operationId !== request.operationId || summary.policyKind !== request.policy.kind || summary.totalCount !== request.population.length || summary.metricName !== manifest.metricPolicy.primaryMetric || canonicalJson(summary.taskset) !== canonicalJson(request.taskset) || manifest.tasksetRelease.id !== request.taskset.id || manifest.tasksetRelease.contentHash !== request.taskset.contentHash || canonicalJson(manifest.population) !== canonicalJson(request.population)) throw new Error("Evaluation run differs from its admitted request or manifest.");
+  if (request.policy.kind === "fixture") {
+    if (manifest.policy.kind !== "fixture" || policySnapshot !== null) throw new Error("Fixture checks cannot claim a model identity.");
+  } else if (request.policy.kind === "hosted_harness") {
+    verifyHarnessExperimentManifest(request, manifest);
+    if (policySnapshot !== null) throw new Error("Harness evaluations retain the native host model configuration.");
+  } else if (manifest.policy.kind !== "model" || !policySnapshot || policySnapshot.modelId !== request.policy.modelId || manifest.policy.model.provider !== policySnapshot.provider || manifest.policy.model.model !== policySnapshot.upstreamModelId || manifest.policy.model.revision !== null || manifest.policy.model.artifactHash !== null || manifest.policy.model.tokenizerRevision !== null || manifest.policy.model.chatTemplateHash !== null || manifest.policy.configurationHash !== await canonicalSha256({ policy: request.policy, snapshot: policySnapshot })) throw new Error("Evaluation model differs from its admitted policy.");
+  return result;
+}
+async function verifyModelTasksetRunResult(value) {
+  const result = ModelTasksetRunResultSchema.parse(value);
+  const { contentHash: actual, ...content } = result;
+  if (await canonicalSha256(content) !== actual) throw new Error("Evaluation result integrity failed.");
+  const { summary, manifest } = await verifyModelTasksetRunDetails(result.run);
+  if (!summary.resultAvailable || !["completed", "failed", "cancelled"].includes(summary.status)) throw new Error("Evaluation result is not terminal.");
+  const ordered = orderTasksetRunReceipts(manifest, result.receipts);
+  if (canonicalJson(ordered) !== canonicalJson(result.receipts)) throw new Error("Evaluation receipts differ from the admitted order.");
+  if (summary.status === "completed" !== (result.metric !== null)) throw new Error("Only completed evaluations retain a metric.");
+  if (result.metric) {
+    assertTasksetMetricResult(result.metric);
+    if (result.metric.runManifest.id !== manifest.id || result.metric.runManifest.contentHash !== manifest.contentHash || canonicalJson(result.metric.tasksetRelease) !== canonicalJson(manifest.tasksetRelease) || canonicalJson(result.metric.policy) !== canonicalJson(manifest.metricPolicy) || canonicalJson(result.metric.receiptRefs) !== canonicalJson(result.receipts.map(({ id, contentHash: contentHash2 }) => ({ id, contentHash: contentHash2 }))) || result.metric.value !== summary.score) throw new Error("Evaluation metric differs from its admitted run or receipt population.");
+  }
+  return result;
+}
+
+export {
+  HarnessExperimentPolicySchema,
+  ModelTasksetRunPolicySchema,
+  ModelTasksetRunRequestSchema,
+  ModelTasksetRunSummarySchema,
+  ModelTasksetRunDetailsSchema,
+  ModelTasksetRunListQuerySchema,
+  ModelTasksetRunPageSchema,
+  ModelTasksetRunResultSchema,
+  verifyHarnessExperimentManifest,
+  verifyModelTasksetRunDetails,
+  verifyModelTasksetRunResult
+};
+//# sourceMappingURL=chunk-62LWLACP.js.map

package/dist/chunk-62LWLACP.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/harness-experiment-policy.ts", "../src/model-taskset-runs-contracts.ts"],
+  "sourcesContent": ["import { z } from \"zod\";\nimport { ProfileEvaluationRunSourceSchema } from \"@openpond/evals\";\n\nconst Id = z.string().trim().min(1).max(240);\nconst Hash = z.string().regex(/^[a-f0-9]{64}$/);\n\n/** The host admits this released component through its native Harness engine.\n * Chat prompt/settings are owned by the released source, not replaced here. */\nexport const HarnessExperimentPolicySchema = z.object({\n  kind: z.literal(\"hosted_harness\"),\n  modelId: Id,\n  reasoningEffort: z.enum([\"off\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"]).optional(),\n  profileRepositoryId: Id,\n  source: ProfileEvaluationRunSourceSchema,\n  modelConfigurationHash: Hash,\n  packageHash: Hash,\n}).strict();\nexport type HarnessExperimentPolicy = z.infer<typeof HarnessExperimentPolicySchema>;\n", "import { z } from \"zod\";\nimport { EvaluationProjectContextSchema } from \"./evaluation-project-context.js\";\nimport { assertContentHash, contentHash } from \"@openpond/harness\";\nimport { TasksetRunManifestSchema, TasksetRunMemberSchema, TasksetMetricResultSchema, assertTasksetMetricResult, orderTasksetRunReceipts } from \"@openpond/evals/metrics\";\nimport { AttemptReceiptSchema } from \"@openpond/evals/runs\";\nimport { ModelProjectVersionedRefSchema } from \"./model-projects.js\";\nimport { ModelStarterAttemptPolicySchema, ModelStarterAttemptSummarySchema } from \"./model-starter-attempts.js\";\nimport { canonicalJson, canonicalSha256 } from \"./protocol.js\";\nimport { HarnessExperimentPolicySchema } from \"./harness-experiment-policy.js\";\nexport { HarnessExperimentPolicySchema, type HarnessExperimentPolicy } from \"./harness-experiment-policy.js\";\n\nconst IdSchema = z.string().trim().min(1).max(200);\nconst HashSchema = z.string().regex(/^[a-f0-9]{64}$/);\nexport const ModelTasksetRunPolicySchema = z.discriminatedUnion(\"kind\", [\n  ModelStarterAttemptPolicySchema.options[0],\n  z.object({ kind: z.literal(\"fixture\") }).strict(),\n  HarnessExperimentPolicySchema,\n]);\nexport const ModelTasksetRunRequestSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelTasksetRunRequest.v1\"),\n  operationId: IdSchema, teamId: IdSchema, modelProjectId: IdSchema.nullable(),\n  name: z.string().trim().min(1).max(200).optional(),\n  project: EvaluationProjectContextSchema.optional(),\n  taskset: ModelProjectVersionedRefSchema, policy: ModelTasksetRunPolicySchema,\n  population: z.array(TasksetRunMemberSchema).min(1).max(10_000),\n}).strict().superRefine((value, context) => {\n  if (new Set(value.population.map(member => member.receiptId)).size !== value.population.length) context.addIssue({ code: \"custom\", path: [\"population\"], message: \"Run receipt identities must be unique.\" });\n  if (value.population.some(member => (member.fixtureId !== null) !== (value.policy.kind === \"fixture\"))) context.addIssue({ code: \"custom\", path: [\"population\"], message: \"Only fixture runs require a fixture identity for every member.\" });\n  if (value.population.some(member => !/^(0|[1-9][0-9]*)$/.test(member.seed) || Number(member.seed) > 2_147_483_647)) context.addIssue({ code: \"custom\", path: [\"population\"], message: \"Hosted environment seeds must be integers from 0 to 2147483647.\" });\n  if (value.policy.kind === \"hosted_harness\" && value.modelProjectId !== null)\n    context.addIssue({ code: \"custom\", path: [\"modelProjectId\"], message: \"A Harness target retains its released Profile binding separately from Model artifacts.\" });\n  if (value.policy.kind === \"hosted_harness\"\n    && new Set(value.population.map(member => canonicalJson([member.taskId, member.seed]))).size !== value.population.length)\n    context.addIssue({ code: \"custom\", path: [\"population\"], message: \"Harness case identities must be unique for each task and seed.\" });\n});\nexport type ModelTasksetRunRequest = z.infer<typeof ModelTasksetRunRequestSchema>;\nexport const ModelTasksetRunSummarySchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelTasksetRunSummary.v1\"),\n  id: IdSchema, revision: z.number().int().positive(), teamId: IdSchema, modelProjectId: IdSchema.nullable(),\n  name: z.string().trim().min(1).max(200).optional(),\n  project: EvaluationProjectContextSchema.optional(),\n  operationId: IdSchema, taskset: ModelProjectVersionedRefSchema, policyKind: z.enum([\"hosted_chat\", \"fixture\", \"hosted_harness\"]),\n  manifestHash: HashSchema,\n  status: z.enum([\"queued\", \"running\", \"cancelling\", \"completed\", \"failed\", \"cancelled\"]),\n  totalCount: z.number().int().min(1).max(10_000),\n  counts: z.object({ pending: z.number().int().nonnegative(), running: z.number().int().nonnegative(), completed: z.number().int().nonnegative(), failed: z.number().int().nonnegative(), cancelled: z.number().int().nonnegative() }).strict(),\n  createdAt: z.iso.datetime(), startedAt: z.iso.datetime().nullable(), completedAt: z.iso.datetime().nullable(),\n  cleanupComplete: z.boolean(), resultAvailable: z.boolean(), score: z.number().min(0).max(1).nullable(),\n  metricName: z.string().min(1).max(240),\n  error: z.object({ code: IdSchema, message: z.string().max(2_000) }).strict().nullable(),\n}).strict().superRefine((value, context) => {\n  if (Object.values(value.counts).reduce((sum, count) => sum + count, 0) !== value.totalCount) context.addIssue({ code: \"custom\", path: [\"counts\"], message: \"Run counts must account for the complete population.\" });\n  if (value.status !== \"completed\" && value.score !== null) context.addIssue({ code: \"custom\", path: [\"score\"], message: \"Only completed evaluations publish a metric value.\" });\n  if ([\"completed\", \"failed\", \"cancelled\"].includes(value.status) && (!value.completedAt || value.counts.pending || value.counts.running)) context.addIssue({ code: \"custom\", message: \"Terminal runs require complete population accounting.\" });\n  if (value.status === \"cancelled\" && !value.cleanupComplete) context.addIssue({ code: \"custom\", message: \"Cancelled runs require confirmed cleanup.\" });\n  if (value.resultAvailable && ![\"completed\", \"failed\", \"cancelled\"].includes(value.status)) context.addIssue({ code: \"custom\", message: \"Run results require terminal population accounting.\" });\n  if (value.status === \"completed\" && (!value.cleanupComplete || !value.resultAvailable)) context.addIssue({ code: \"custom\", message: \"Completed evaluations require retained results and confirmed cleanup.\" });\n});\nexport type ModelTasksetRunSummary = z.infer<typeof ModelTasksetRunSummarySchema>;\nexport const ModelTasksetRunDetailsSchema = z.object({\n  summary: ModelTasksetRunSummarySchema,\n  request: ModelTasksetRunRequestSchema,\n  manifest: TasksetRunManifestSchema,\n  policySnapshot: ModelStarterAttemptSummarySchema.shape.policySnapshot,\n}).strict();\nexport type ModelTasksetRunDetails = z.infer<typeof ModelTasksetRunDetailsSchema>;\nexport const ModelTasksetRunListQuerySchema = z.object({ modelProjectId: IdSchema.optional(), projectId: EvaluationProjectContextSchema.shape.id.optional(), afterId: IdSchema.optional(), limit: z.number().int().min(1).max(100).default(25) }).strict();\nexport const ModelTasksetRunPageSchema = z.object({ items: z.array(ModelTasksetRunSummarySchema).max(100), nextCursor: IdSchema.nullable() }).strict();\nexport const ModelTasksetRunResultSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelTasksetRunResult.v1\"),\n  run: ModelTasksetRunDetailsSchema,\n  receipts: z.array(AttemptReceiptSchema).min(1).max(10_000),\n  metric: TasksetMetricResultSchema.nullable(),\n  contentHash: HashSchema,\n}).strict();\nexport type ModelTasksetRunResult = z.infer<typeof ModelTasksetRunResultSchema>;\n\nexport function verifyHarnessExperimentManifest(request: ModelTasksetRunRequest, manifest: z.infer<typeof TasksetRunManifestSchema>) {\n  assertContentHash(manifest, \"Taskset run manifest\");\n  const policy = request.policy;\n  if (policy.kind !== \"hosted_harness\" || manifest.execution.kind !== \"harness\"\n    || canonicalJson(manifest.profileEvaluation) !== canonicalJson(policy.source)\n    || canonicalJson(manifest.execution.harnessRelease) !== canonicalJson(policy.source.harnessRelease)\n    || manifest.metadata.profileRepositoryId !== policy.profileRepositoryId\n    || manifest.packageHash !== policy.packageHash || manifest.policy.kind !== \"model\"\n    || manifest.policy.model.provider !== \"openpond\" || manifest.policy.model.model !== policy.modelId\n    || manifest.policy.model.revision !== null || manifest.policy.model.artifactHash !== null\n    || manifest.policy.model.tokenizerRevision !== null || manifest.policy.model.chatTemplateHash !== null\n    || manifest.policy.configurationHash !== policy.modelConfigurationHash\n    || manifest.tasksetRelease.id !== request.taskset.id || manifest.tasksetRelease.contentHash !== request.taskset.contentHash\n    || canonicalJson(manifest.population) !== canonicalJson(request.population)\n    || manifest.population.some(member => member.receiptId !== `evaluation-${contentHash([manifest.id, member.taskId, member.seed]).slice(0, 32)}`))\n    throw new Error(\"Harness evaluation differs from its admitted source, package or model configuration.\");\n}\n\n/** Server artifact ownership authenticates the producer. These checks bind all\n * portable projections to the admitted request, population and policy. */\nexport async function verifyModelTasksetRunDetails(value: unknown): Promise<ModelTasksetRunDetails> {\n  const result = ModelTasksetRunDetailsSchema.parse(value);\n  const { summary, request, manifest, policySnapshot } = result;\n  assertContentHash(manifest, \"Taskset run manifest\");\n  if (manifest.contentHash !== summary.manifestHash\n    || manifest.id !== summary.id || manifest.createdAt !== summary.createdAt || summary.teamId !== request.teamId || summary.modelProjectId !== request.modelProjectId\n    || canonicalJson(summary.project ?? null) !== canonicalJson(request.project ?? null)\n    || canonicalJson(manifest.metadata.project ?? null) !== canonicalJson(request.project ?? null)\n    || (summary.name ?? null) !== (request.name ?? null)\n    || summary.operationId !== request.operationId || summary.policyKind !== request.policy.kind\n    || summary.totalCount !== request.population.length || summary.metricName !== manifest.metricPolicy.primaryMetric\n    || canonicalJson(summary.taskset) !== canonicalJson(request.taskset)\n    || manifest.tasksetRelease.id !== request.taskset.id || manifest.tasksetRelease.contentHash !== request.taskset.contentHash\n    || canonicalJson(manifest.population) !== canonicalJson(request.population)) throw new Error(\"Evaluation run differs from its admitted request or manifest.\");\n  if (request.policy.kind === \"fixture\") {\n    if (manifest.policy.kind !== \"fixture\" || policySnapshot !== null) throw new Error(\"Fixture checks cannot claim a model identity.\");\n  } else if (request.policy.kind === \"hosted_harness\") {\n    verifyHarnessExperimentManifest(request, manifest);\n    if (policySnapshot !== null) throw new Error(\"Harness evaluations retain the native host model configuration.\");\n  } else if (manifest.policy.kind !== \"model\" || !policySnapshot || policySnapshot.modelId !== request.policy.modelId\n    || manifest.policy.model.provider !== policySnapshot.provider || manifest.policy.model.model !== policySnapshot.upstreamModelId\n    || manifest.policy.model.revision !== null || manifest.policy.model.artifactHash !== null || manifest.policy.model.tokenizerRevision !== null || manifest.policy.model.chatTemplateHash !== null\n    || manifest.policy.configurationHash !== await canonicalSha256({ policy: request.policy, snapshot: policySnapshot })) throw new Error(\"Evaluation model differs from its admitted policy.\");\n  return result;\n}\n\nexport async function verifyModelTasksetRunResult(value: unknown): Promise<ModelTasksetRunResult> {\n  const result = ModelTasksetRunResultSchema.parse(value);\n  const { contentHash: actual, ...content } = result;\n  if (await canonicalSha256(content) !== actual) throw new Error(\"Evaluation result integrity failed.\");\n  const { summary, manifest } = await verifyModelTasksetRunDetails(result.run);\n  if (!summary.resultAvailable || ![\"completed\", \"failed\", \"cancelled\"].includes(summary.status)) throw new Error(\"Evaluation result is not terminal.\");\n  const ordered = orderTasksetRunReceipts(manifest, result.receipts);\n  if (canonicalJson(ordered) !== canonicalJson(result.receipts)) throw new Error(\"Evaluation receipts differ from the admitted order.\");\n  if ((summary.status === \"completed\") !== (result.metric !== null)) throw new Error(\"Only completed evaluations retain a metric.\");\n  if (result.metric) {\n    assertTasksetMetricResult(result.metric);\n    if (result.metric.runManifest.id !== manifest.id || result.metric.runManifest.contentHash !== manifest.contentHash\n      || canonicalJson(result.metric.tasksetRelease) !== canonicalJson(manifest.tasksetRelease)\n      || canonicalJson(result.metric.policy) !== canonicalJson(manifest.metricPolicy)\n      || canonicalJson(result.metric.receiptRefs) !== canonicalJson(result.receipts.map(({ id, contentHash }) => ({ id, contentHash })))\n      || result.metric.value !== summary.score) throw new Error(\"Evaluation metric differs from its admitted run or receipt population.\");\n  }\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": ["z", "z", "contentHash"]
+}

package/dist/chunk-EMANJDJR.js

@@ -0,0 +1,393 @@
+import {
+  ModelTasksetRunRequestSchema,
+  verifyHarnessExperimentManifest,
+  verifyModelTasksetRunDetails
+} from "./chunk-62LWLACP.js";
+import {
+  ImmutableReleaseRefSchema,
+  contentHash
+} from "./chunk-QUOW6URQ.js";
+
+// src/experiment-field-mappings.ts
+import { z } from "zod";
+var Segment = z.string().min(1).max(200).refine((value) => !["__proto__", "prototype", "constructor"].includes(value), "Use an ordinary field name.");
+var Path = z.array(Segment).min(1).max(20);
+var Slot = z.enum(["input", "output", "expectedOutput", "evaluatorContext"]);
+var ExperimentFieldMappingSchema = z.object({
+  destination: Slot,
+  path: Path,
+  source: Slot,
+  sourcePath: z.array(Segment).max(20)
+}).strict();
+var ExperimentFieldMappingsSchema = z.array(ExperimentFieldMappingSchema).max(100).superRefine((mappings, context) => {
+  for (const [index, mapping] of mappings.entries()) {
+    if (mappings.slice(0, index).some((previous) => previous.destination === mapping.destination && (prefix(previous.path, mapping.path) || prefix(mapping.path, previous.path))))
+      context.addIssue({ code: "custom", path: [index, "path"], message: "Mapped destination paths must not overlap." });
+  }
+});
+function mapExperimentGradingFields(fields, raw) {
+  const mappings = ExperimentFieldMappingsSchema.parse(raw);
+  const mapped = structuredClone(fields);
+  for (const mapping of mappings) {
+    let value = fields[mapping.source];
+    for (const segment of mapping.sourcePath) {
+      if (!record(value) || !Object.hasOwn(value, segment)) throw new Error("The configured grader source field is unavailable.");
+      value = value[segment];
+    }
+    if (value === void 0) throw new Error("The configured grader source field is unavailable.");
+    let destination = mapped[mapping.destination];
+    if (destination === null) mapped[mapping.destination] = destination = {};
+    for (const segment of mapping.path.slice(0, -1)) {
+      const existing = Object.hasOwn(destination, segment) ? destination[segment] : void 0;
+      if (existing !== void 0 && !record(existing)) throw new Error("A grader destination path crosses a scalar field.");
+      if (existing === void 0) destination[segment] = {};
+      destination = destination[segment];
+    }
+    destination[mapping.path.at(-1)] = structuredClone(value);
+  }
+  return mapped;
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function prefix(left, right) {
+  return left.length <= right.length && left.every((segment, index) => segment === right[index]);
+}
+
+// src/experiment-contracts.ts
+import { FeedbackKeySchema } from "@openpond/evals/rewards";
+import { TasksetRunManifestSchema } from "@openpond/evals/metrics";
+import { z as z2 } from "zod";
+var Id = z2.string().trim().min(1).max(200);
+var Hash = z2.string().regex(/^[a-f0-9]{64}$/);
+var ExperimentDefinitionRefSchema = z2.object({
+  id: Id,
+  revision: z2.number().int().positive(),
+  contentHash: Hash
+}).strict();
+var ExperimentGraderPinSchema = z2.object({
+  id: Id,
+  version: z2.string().min(1).max(200),
+  contentHash: Hash,
+  feedbackKey: FeedbackKeySchema,
+  release: ExperimentDefinitionRefSchema.nullable(),
+  mappings: ExperimentFieldMappingsSchema.optional()
+}).strict();
+var ExperimentGraderSelectionSchema = z2.object({ id: Id, version: z2.string().min(1).max(200), contentHash: Hash, mappings: ExperimentFieldMappingsSchema }).strict();
+var SaveExperimentSchema = z2.object({
+  operationId: Id,
+  id: Id.optional(),
+  expectedRevision: z2.number().int().nonnegative(),
+  request: ModelTasksetRunRequestSchema,
+  maximumCostUsd: z2.number().finite().positive().max(1e4),
+  graders: z2.array(ExperimentGraderSelectionSchema).min(1).max(100).optional()
+}).strict().superRefine((value, ctx) => {
+  if (!value.request.name) ctx.addIssue({ code: "custom", path: ["request", "name"], message: "Name this Experiment before saving it." });
+  if (Boolean(value.id) !== value.expectedRevision > 0) ctx.addIssue({ code: "custom", path: ["expectedRevision"], message: "An update requires its saved definition revision." });
+  if (Math.round(value.maximumCostUsd * 1e6) < 1) ctx.addIssue({ code: "custom", path: ["maximumCostUsd"], message: "The budget must be at least $0.000001." });
+  if (value.graders && new Set(value.graders.map((grader) => grader.id)).size !== value.graders.length) ctx.addIssue({ code: "custom", path: ["graders"], message: "Select each grader once." });
+});
+var DefinitionContent = z2.object({
+  schemaVersion: z2.literal("openpond.experimentDefinition.v1"),
+  id: Id,
+  teamId: Id,
+  revision: z2.number().int().positive(),
+  request: ModelTasksetRunRequestSchema,
+  maximumCostUsd: z2.number().finite().positive().max(1e4),
+  graders: z2.array(ExperimentGraderPinSchema).min(1).max(100),
+  createdAt: z2.iso.datetime(),
+  updatedAt: z2.iso.datetime()
+}).strict();
+var ExperimentDefinitionSchema = DefinitionContent.extend({ contentHash: Hash });
+var StartExperimentSchema = z2.object({ operationId: Id, definition: ExperimentDefinitionRefSchema }).strict();
+var ExperimentListQuerySchema = z2.object({
+  projectId: Id.optional(),
+  datasetHash: Hash.optional(),
+  search: z2.string().trim().max(200).optional(),
+  afterId: Id.optional(),
+  limit: z2.number().int().min(1).max(100).default(30)
+}).strict();
+var ExperimentExecutionContextSchema = z2.object({
+  definition: ExperimentDefinitionRefSchema,
+  maximumCostUsd: z2.number().finite().positive().max(1e4),
+  graders: z2.array(ExperimentGraderPinSchema).min(1).max(100)
+}).strict();
+var PrepareHarnessExperimentSchema = z2.object({
+  operationId: Id,
+  profileRepositoryId: Id,
+  definitionId: Id,
+  modelId: Id,
+  reasoningEffort: z2.enum(["off", "low", "medium", "high", "xhigh", "max"]).optional(),
+  maximumCostUsd: z2.number().finite().positive().max(1e4)
+}).strict();
+var PreparedHarnessExperimentSchema = z2.object({
+  request: ModelTasksetRunRequestSchema,
+  manifest: TasksetRunManifestSchema,
+  maximumCostUsd: z2.number().finite().positive().max(1e4),
+  graders: z2.array(ExperimentGraderPinSchema).min(1).max(100)
+}).strict();
+function verifyExperimentDefinition(value) {
+  const parsed = ExperimentDefinitionSchema.parse(value);
+  const { contentHash: actual, ...content } = parsed;
+  if (actual !== contentHash(content) || parsed.request.teamId !== parsed.teamId || !parsed.request.name)
+    throw new Error("Experiment definition differs from its immutable content.");
+  if (new Set(parsed.graders.map((item) => item.feedbackKey)).size !== parsed.graders.length)
+    throw new Error("Experiment feedback keys must be distinct.");
+  return parsed;
+}
+var experimentDefinitionRef = (value) => ({
+  id: value.id,
+  revision: value.revision,
+  contentHash: value.contentHash
+});
+
+// src/experiment-scoring-contracts.ts
+import { z as z3 } from "zod";
+import { RewardReleaseRefSchema } from "@openpond/evals/rewards";
+var Id2 = z3.string().trim().min(1).max(200);
+var ExperimentScoringRequestSchema = z3.object({
+  operationId: Id2,
+  execution: ImmutableReleaseRefSchema,
+  graders: z3.array(RewardReleaseRefSchema).min(1).max(100),
+  maximumCostUsd: z3.number().finite().min(1e-6).max(1e4),
+  mappings: z3.array(z3.object({ graderId: Id2, fields: ExperimentFieldMappingsSchema }).strict()).max(100).optional()
+}).strict().superRefine((value, context) => {
+  if (new Set(value.graders.map((grader) => grader.id)).size !== value.graders.length)
+    context.addIssue({ code: "custom", path: ["graders"], message: "Select each grader once." });
+  if (value.mappings && (new Set(value.mappings.map((mapping) => mapping.graderId)).size !== value.mappings.length || value.mappings.some((mapping) => !value.graders.some((grader) => grader.id === mapping.graderId))))
+    context.addIssue({ code: "custom", path: ["mappings"], message: "Map each selected grader at most once." });
+});
+var ScoringPassContent = z3.object({
+  schemaVersion: z3.literal("openpond.experimentScoringPass.v1"),
+  id: Id2,
+  teamId: Id2,
+  revision: z3.number().int().positive(),
+  request: ExperimentScoringRequestSchema,
+  graders: z3.array(ExperimentGraderPinSchema).min(1).max(100),
+  status: z3.enum(["queued", "running", "cancelling", "completed", "failed", "cancelled"]),
+  totalCount: z3.number().int().min(1).max(1e4),
+  counts: z3.object({
+    pending: z3.number().int().nonnegative(),
+    running: z3.number().int().nonnegative(),
+    scored: z3.number().int().nonnegative(),
+    unavailable: z3.number().int().nonnegative(),
+    failed: z3.number().int().nonnegative(),
+    cancelled: z3.number().int().nonnegative()
+  }).strict(),
+  resultAvailable: z3.boolean(),
+  createdAt: z3.iso.datetime(),
+  startedAt: z3.iso.datetime().nullable(),
+  completedAt: z3.iso.datetime().nullable(),
+  error: z3.object({ code: Id2, message: z3.string().max(2e3) }).strict().nullable()
+}).strict();
+var ExperimentScoringPassSchema = ScoringPassContent.extend({ contentHash: z3.string().regex(/^[a-f0-9]{64}$/) });
+function verifyExperimentScoringPass(value) {
+  const pass = ExperimentScoringPassSchema.parse(value);
+  const { contentHash: actual, ...content } = pass;
+  if (contentHash(content) !== actual || Object.values(pass.counts).reduce((sum, count) => sum + count, 0) !== pass.totalCount)
+    throw new Error("Scoring pass integrity or population accounting failed.");
+  const terminal = ["completed", "failed", "cancelled"].includes(pass.status);
+  if (terminal && (!pass.completedAt || pass.counts.pending || pass.counts.running) || !terminal && (pass.completedAt !== null || pass.resultAvailable) || pass.status === "completed" && !pass.resultAvailable)
+    throw new Error("Scoring pass lifecycle differs from its retained result.");
+  if (pass.graders.length !== pass.request.graders.length || new Set(pass.graders.map((grader) => grader.feedbackKey)).size !== pass.graders.length || pass.graders.some((grader, index) => contentHash(grader.release) !== contentHash(pass.request.graders[index]) || contentHash(grader.mappings ?? []) !== contentHash(pass.request.mappings?.find((mapping) => mapping.graderId === grader.release?.id)?.fields ?? [])))
+    throw new Error("Scoring pass graders differ from their exact admission.");
+  return pass;
+}
+
+// src/experiment-client.ts
+import { z as z4 } from "zod";
+import { compareExperiments, verifyExperimentEvidence } from "@openpond/evals/experiments";
+var Id3 = z4.string().trim().min(1).max(200);
+var OpenPondExperimentError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "OpenPondExperimentError";
+  }
+  status;
+  code;
+};
+var OpenPondExperimentsClient = class {
+  constructor(options) {
+    this.options = options;
+    const url = new URL(options.baseUrl);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim())
+      throw new Error("A clean API origin and workspace credentials are required.");
+    this.baseUrl = url.toString().replace(/\/+$/, "");
+  }
+  options;
+  baseUrl;
+  /** Resolves a released target without saving a definition or dispatching it. */
+  async prepareHarness(value, signal) {
+    const request = PrepareHarnessExperimentSchema.parse(value);
+    const result = PreparedHarnessExperimentSchema.parse(await this.request("/harness-setup", "POST", request, signal));
+    verifyHarnessExperimentManifest(result.request, result.manifest);
+    const policy = result.request.policy;
+    if (result.request.teamId !== this.options.teamId || result.request.operationId !== request.operationId || policy.kind !== "hosted_harness" || policy.profileRepositoryId !== request.profileRepositoryId || policy.source.definitionId !== request.definitionId || policy.modelId !== request.modelId || policy.reasoningEffort !== request.reasoningEffort || result.maximumCostUsd !== request.maximumCostUsd || result.manifest.limits.maximumSpendUsd !== request.maximumCostUsd)
+      throw new Error("Harness preparation differs from its requested scope or configuration.");
+    return result;
+  }
+  async save(value, signal) {
+    const request = SaveExperimentSchema.parse(value);
+    if (request.request.teamId !== this.options.teamId) throw new Error("Experiment workspace mismatch.");
+    const result = this.definition(await this.request("", "POST", request, signal), request.id);
+    if (result.revision !== request.expectedRevision + 1 || contentHash(result.request) !== contentHash(request.request) || result.maximumCostUsd !== request.maximumCostUsd) throw new Error("Experiment save receipt differs from its submitted configuration.");
+    if (request.graders && contentHash(request.graders) !== contentHash(result.graders.map((grader) => ({ id: grader.id, version: grader.version, contentHash: grader.contentHash, mappings: grader.mappings ?? [] }))))
+      throw new Error("Experiment save receipt differs from its selected graders or mappings.");
+    return result;
+  }
+  async get(id, options = {}) {
+    const reference = options.reference ? ExperimentDefinitionRefSchema.parse(options.reference) : void 0;
+    if (reference && reference.id !== id) throw new Error("Experiment reference identity mismatch.");
+    const suffix = reference ? `?${new URLSearchParams({ revision: String(reference.revision), contentHash: reference.contentHash })}` : "";
+    const result = this.definition(await this.request(`/${encodeURIComponent(Id3.parse(id))}${suffix}`, "GET", void 0, options.signal), id);
+    if (options.reference && contentHash(experimentDefinitionRef(result)) !== contentHash(options.reference)) throw new Error("Experiment revision mismatch.");
+    return result;
+  }
+  async list(value = {}, signal) {
+    const query = ExperimentListQuerySchema.parse(value);
+    const params = new URLSearchParams(Object.entries(query).map(([key, value2]) => [key, String(value2)]));
+    const page = z4.object({ items: z4.array(z4.unknown()).max(100), nextCursor: Id3.nullable() }).strict().parse(await this.request(`?${params}`, "GET", void 0, signal));
+    const items = page.items.map((value2) => this.definition(value2));
+    if (items.length > query.limit || new Set(items.map((item) => item.id)).size !== items.length || items.some((item) => query.projectId && item.request.project?.id !== query.projectId || query.datasetHash && item.request.taskset.contentHash !== query.datasetHash))
+      throw new Error("Experiment page differs from its selected scope.");
+    return { items, nextCursor: page.nextCursor };
+  }
+  async start(value, signal) {
+    const request = StartExperimentSchema.parse(value);
+    const response = z4.object({ definition: z4.unknown(), run: z4.unknown() }).strict().parse(
+      await this.request(`/${encodeURIComponent(request.definition.id)}/start`, "POST", request, signal)
+    );
+    const definition = this.definition(response.definition, request.definition.id);
+    if (contentHash(experimentDefinitionRef(definition)) !== contentHash(request.definition)) throw new Error("Experiment Start revision mismatch.");
+    const result = await verifyModelTasksetRunDetails(response.run);
+    if (result.summary.teamId !== this.options.teamId || result.request.operationId !== request.operationId || contentHash(savedRequestPopulation(result.request)) !== contentHash(savedRequestPopulation({ ...definition.request, operationId: request.operationId })) || contentHash(result.manifest.metadata.experimentDefinition) !== contentHash(request.definition) || result.manifest.metadata.experimentConfigurationHash !== contentHash({ definition: request.definition, maximumCostUsd: definition.maximumCostUsd, graders: definition.graders }))
+      throw new Error("Experiment execution differs from its saved configuration.");
+    return result;
+  }
+  async result(executionId, signal) {
+    const value = z4.object({ executionId: Id3, passId: Id3.nullable(), manifest: z4.unknown(), result: z4.unknown() }).strict().parse(await this.request(`/executions/${encodeURIComponent(Id3.parse(executionId))}/result`, "GET", void 0, signal));
+    const evidence = verifyExperimentEvidence(value);
+    if (value.executionId !== executionId || evidence.manifest.teamId !== this.options.teamId || evidence.manifest.lineage?.execution.id !== executionId || evidence.manifest.lineage.scoringPassId !== value.passId) throw new Error("Experiment result identity mismatch.");
+    return { ...evidence, executionId, passId: value.passId };
+  }
+  async executions(definitionId, options = {}) {
+    const params = new URLSearchParams(options.afterId ? { afterId: Id3.parse(options.afterId) } : {});
+    const page = z4.object({ items: z4.array(z4.unknown()).max(30), nextCursor: Id3.nullable() }).strict().parse(
+      await this.request(`/${encodeURIComponent(Id3.parse(definitionId))}/executions?${params}`, "GET", void 0, options.signal)
+    );
+    const items = await Promise.all(page.items.map((value) => verifyModelTasksetRunDetails(value)));
+    if (items.some((item) => item.summary.teamId !== this.options.teamId || ExperimentDefinitionRefSchema.parse(item.manifest.metadata.experimentDefinition).id !== definitionId) || new Set(items.map((item) => item.summary.id)).size !== items.length)
+      throw new Error("Experiment execution page has invalid ownership or repeated identities.");
+    return { items, nextCursor: page.nextCursor };
+  }
+  async execution(id, signal) {
+    return this.executionDetails(await this.request(`/executions/${encodeURIComponent(Id3.parse(id))}`, "GET", void 0, signal), id);
+  }
+  async cancel(id, signal) {
+    return this.executionDetails(await this.request(`/executions/${encodeURIComponent(Id3.parse(id))}/cancel`, "POST", {}, signal), id);
+  }
+  /** Retry intentionally creates another execution; a transport retry reuses the same operation id. */
+  async retry(id, operationId, signal) {
+    const result = await this.executionDetails(await this.request(`/executions/${encodeURIComponent(Id3.parse(id))}/retry`, "POST", { operationId: Id3.parse(operationId) }, signal));
+    if (result.request.operationId !== operationId) throw new Error("Experiment retry operation mismatch.");
+    return result;
+  }
+  async score(value, signal) {
+    const request = ExperimentScoringRequestSchema.parse(value);
+    const pass = this.pass(await this.request(`/executions/${encodeURIComponent(request.execution.id)}/scoring-passes`, "POST", request, signal));
+    if (contentHash(pass.request) !== contentHash(request)) throw new Error("Scoring admission differs from its submitted inputs.");
+    return pass;
+  }
+  async scoringPass(id, signal) {
+    return this.pass(await this.request(`/scoring-passes/${encodeURIComponent(Id3.parse(id))}`, "GET", void 0, signal), id);
+  }
+  async scoringPasses(executionId, options = {}) {
+    const params = new URLSearchParams(options.afterId ? { afterId: Id3.parse(options.afterId) } : {});
+    const page = z4.object({ items: z4.array(z4.unknown()).max(30), nextCursor: Id3.nullable() }).strict().parse(
+      await this.request(`/executions/${encodeURIComponent(Id3.parse(executionId))}/scoring-passes?${params}`, "GET", void 0, options.signal)
+    );
+    const items = page.items.map((value) => this.pass(value));
+    if (items.some((item) => item.request.execution.id !== executionId) || new Set(items.map((item) => item.id)).size !== items.length)
+      throw new Error("Scoring pass page differs from its execution ownership.");
+    return { items, nextCursor: page.nextCursor };
+  }
+  async cancelScoringPass(id, signal) {
+    return this.pass(await this.request(`/scoring-passes/${encodeURIComponent(Id3.parse(id))}/cancel`, "POST", {}, signal), id);
+  }
+  async scoringResult(id, signal) {
+    const value = z4.object({ executionId: Id3, passId: Id3, manifest: z4.unknown(), result: z4.unknown() }).strict().parse(
+      await this.request(`/scoring-passes/${encodeURIComponent(Id3.parse(id))}/result`, "GET", void 0, signal)
+    );
+    const evidence = verifyExperimentEvidence(value);
+    if (value.passId !== id || evidence.manifest.teamId !== this.options.teamId || evidence.manifest.id !== id || evidence.manifest.lineage?.execution.id !== value.executionId || evidence.manifest.lineage.scoringPassId !== id)
+      throw new Error("Scoring result identity mismatch.");
+    return { ...evidence, executionId: value.executionId, passId: id };
+  }
+  async compare(baselineId, candidateId, signal) {
+    const read = (id) => id.startsWith("score_") ? this.scoringResult(id, signal) : this.result(id, signal);
+    const [baseline, candidate] = await Promise.all([read(baselineId), read(candidateId)]);
+    return { baseline, candidate, comparison: compareExperiments(baseline, candidate) };
+  }
+  definition(value, id) {
+    const result = verifyExperimentDefinition(value);
+    if (result.teamId !== this.options.teamId || id && result.id !== id) throw new Error("Experiment identity mismatch.");
+    return result;
+  }
+  async executionDetails(value, id) {
+    const details = await verifyModelTasksetRunDetails(value);
+    if (details.summary.teamId !== this.options.teamId || id && details.summary.id !== id) throw new Error("Experiment execution identity mismatch.");
+    return details;
+  }
+  pass(value, id) {
+    const pass = verifyExperimentScoringPass(value);
+    if (pass.teamId !== this.options.teamId || id && pass.id !== id) throw new Error("Scoring pass identity mismatch.");
+    return pass;
+  }
+  async request(path, method, body, signal) {
+    const response = await (this.options.fetch ?? fetch)(`${this.baseUrl}/v1/experiments${path}`, {
+      method,
+      signal,
+      redirect: "error",
+      headers: { Authorization: `Bearer ${this.options.apiKey}`, "X-OpenPond-Team-Id": this.options.teamId, "Content-Type": "application/json", Accept: "application/json" },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    const value = await response.json();
+    if (!response.ok) {
+      const parsed = z4.object({ code: z4.string(), message: z4.string() }).safeParse(value);
+      throw new OpenPondExperimentError(response.status, parsed.success ? parsed.data.code : "experiment_request_failed", parsed.success ? parsed.data.message : "Experiment request failed.");
+    }
+    return value;
+  }
+};
+function savedRequestPopulation(request) {
+  return request.policy.kind === "hosted_harness" ? {
+    ...request,
+    population: request.population.map(({ receiptId: _id, ...member }) => member)
+  } : request;
+}
+
+export {
+  ExperimentFieldMappingSchema,
+  ExperimentFieldMappingsSchema,
+  mapExperimentGradingFields,
+  ExperimentDefinitionRefSchema,
+  ExperimentGraderPinSchema,
+  ExperimentGraderSelectionSchema,
+  SaveExperimentSchema,
+  ExperimentDefinitionSchema,
+  StartExperimentSchema,
+  ExperimentListQuerySchema,
+  ExperimentExecutionContextSchema,
+  PrepareHarnessExperimentSchema,
+  PreparedHarnessExperimentSchema,
+  verifyExperimentDefinition,
+  experimentDefinitionRef,
+  ExperimentScoringRequestSchema,
+  ExperimentScoringPassSchema,
+  verifyExperimentScoringPass,
+  OpenPondExperimentError,
+  OpenPondExperimentsClient
+};
+//# sourceMappingURL=chunk-EMANJDJR.js.map