openpond-sdk 0.12.3 → 0.12.5

package/dist/chunk-FHCSDXIA.js

@@ -1,1417 +0,0 @@
-import {
-  ModelTasksetAuthoringSchema
-} from "./chunk-2U54EOXJ.js";
-import {
-  ChatModelRefSchema
-} from "./chunk-KAE7AMYE.js";
-import {
-  ModelProjectVersionedRefSchema,
-  canonicalJson
-} from "./chunk-TCHAWJMB.js";
-import {
-  ImmutableAssetRefSchema,
-  ImmutableReleaseRefSchema,
-  ReleaseHashSchema,
-  ReleaseIdSchema,
-  contentHash,
-  sha256
-} from "./chunk-COPVBJPL.js";
-
-// src/connected-dataset-source.ts
-import { z } from "zod";
-import { ConnectedSourceKindSchema } from "@openpond/evals/connected-evidence";
-var ConnectedDatasetSourceRefSchema = z.object({
-  schemaVersion: z.literal("openpond.connectedDatasetSource.v1"),
-  kind: z.literal("connected_activity"),
-  id: z.string().min(1).max(240),
-  profileId: z.string().min(1).max(240),
-  title: z.string().min(1).max(500),
-  sourceHash: z.string().regex(/^[a-f0-9]{64}$/),
-  occurredAt: z.string().datetime(),
-  licensingStatus: z.enum(["pending", "approved", "review", "blocked"]),
-  secretScanStatus: z.enum(["pending", "passed", "blocked"]),
-  piiScanStatus: z.enum(["pending", "passed", "review", "blocked"]),
-  origin: ConnectedSourceKindSchema,
-  sourceId: z.string().min(1).max(500),
-  sessionId: z.string().min(1).max(500),
-  normalizerVersion: z.string().min(1).max(200),
-  projection: z.enum(["turn", "conversation"]),
-  ownerUserId: z.string().min(1).max(500),
-  purpose: z.literal("recorded_evaluation"),
-  sourceFileHashes: z.array(z.string().regex(/^[a-f0-9]{64}$/)).max(100).optional(),
-  metadata: z.record(z.string(), z.unknown()).default({})
-}).strict();
-
-// src/taskset-draft-dataset-artifacts.ts
-import { z as z2 } from "zod";
-var IdSchema = z2.string().trim().min(1).max(240);
-var TimestampSchema = z2.string().trim().min(1);
-var HashSchema = z2.string().trim().min(8).max(256);
-var RelativePathSchema = z2.string().trim().min(1).max(1e3).refine(
-  (value) => !value.startsWith("/") && !value.startsWith("\\") && !value.split(/[\\/]/).includes(".."),
-  "Artifact paths must be relative and stay inside the Dataset."
-);
-var DatasetSplitSchema = z2.enum([
-  "train",
-  "validation",
-  "test",
-  "frozen_eval"
-]);
-var DatasetSemanticFieldSchema = z2.object({
-  name: z2.string().trim().min(1).max(500),
-  semanticRole: z2.enum([
-    "row_id",
-    "cluster_id",
-    "prompt",
-    "messages",
-    "demonstration",
-    "chosen",
-    "rejected",
-    "expected_output",
-    "privileged_context",
-    "reward",
-    "feedback",
-    "tag",
-    "metadata"
-  ]),
-  logicalType: z2.enum([
-    "string",
-    "integer",
-    "float",
-    "boolean",
-    "json",
-    "messages"
-  ]),
-  nullable: z2.boolean(),
-  policy: z2.enum(["visible", "privileged", "metadata"])
-});
-var DatasetSemanticSchemaSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetSemanticSchema.v1"),
-  fields: z2.array(DatasetSemanticFieldSchema).min(1).max(1e4),
-  schemaHash: HashSchema
-});
-var DatasetShardRefSchema = z2.object({
-  id: IdSchema,
-  split: DatasetSplitSchema,
-  path: RelativePathSchema,
-  contentHash: HashSchema,
-  schemaHash: HashSchema,
-  sizeBytes: z2.number().int().nonnegative(),
-  rowCount: z2.number().int().positive(),
-  rowGroupCount: z2.number().int().positive()
-});
-var DatasetArtifactManifestSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetArtifact.v1"),
-  id: IdSchema,
-  tasksetId: IdSchema,
-  tasksetRevision: z2.number().int().positive(),
-  contentHash: HashSchema,
-  format: z2.literal("parquet"),
-  schema: DatasetSemanticSchemaSchema,
-  shards: z2.array(DatasetShardRefSchema).min(1).max(1e5),
-  rowCount: z2.number().int().positive(),
-  splitCounts: z2.record(DatasetSplitSchema, z2.number().int().nonnegative()),
-  sourceReceiptRefs: z2.array(IdSchema).min(1).max(1e5),
-  mappingHash: HashSchema,
-  qualityReportHash: HashSchema,
-  createdAt: TimestampSchema
-});
-var DatasetArtifactSummarySchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetArtifactSummary.v1"),
-  artifactId: IdSchema,
-  tasksetId: IdSchema,
-  tasksetRevision: z2.number().int().positive(),
-  format: z2.literal("parquet"),
-  rowCount: z2.number().int().positive(),
-  splitCounts: z2.record(DatasetSplitSchema, z2.number().int().nonnegative()),
-  sizeBytes: z2.number().int().nonnegative(),
-  contentHash: HashSchema,
-  available: z2.boolean(),
-  unavailableReason: z2.string().trim().min(1).max(2e3).nullable(),
-  createdAt: TimestampSchema
-});
-var DatasetCatalogItemSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetCatalogItem.v1"),
-  tasksetId: IdSchema,
-  tasksetRevision: z2.number().int().positive(),
-  artifactId: IdSchema.nullable(),
-  name: z2.string().trim().min(1).max(500),
-  status: z2.enum([
-    "draft",
-    "awaiting_disclosure_approval",
-    "awaiting_materialization_approval",
-    "materializing",
-    "validating",
-    "needs_review",
-    "baselining",
-    "ready",
-    "blocked",
-    "failed",
-    "archived"
-  ]),
-  storageKind: z2.enum(["inline", "parquet"]),
-  rowCount: z2.number().int().nonnegative(),
-  splitCounts: z2.record(DatasetSplitSchema, z2.number().int().nonnegative()),
-  sizeBytes: z2.number().int().nonnegative().nullable(),
-  available: z2.boolean(),
-  unavailableReason: z2.string().trim().min(1).max(2e3).nullable(),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-});
-var DatasetCatalogResponseSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetCatalog.v1"),
-  profileId: IdSchema,
-  datasets: z2.array(DatasetCatalogItemSchema),
-  generatedAt: TimestampSchema
-});
-var DatasetArtifactRegistryEntrySchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetArtifactRegistry.v1"),
-  manifest: DatasetArtifactManifestSchema,
-  profileId: IdSchema,
-  storageRoot: z2.string().trim().min(1).max(4e3),
-  relativeManifestPath: RelativePathSchema,
-  available: z2.boolean(),
-  unavailableReason: z2.string().trim().min(1).max(2e3).nullable(),
-  verifiedAt: TimestampSchema.nullable(),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-});
-var DatasetRowPageRequestSchema = z2.object({
-  split: DatasetSplitSchema.nullable().default(null),
-  cursor: z2.string().trim().min(1).max(2e3).nullable().default(null),
-  limit: z2.number().int().min(1).max(100).default(25),
-  columns: z2.array(z2.string().trim().min(1).max(500)).max(100).default([])
-});
-var DatasetRowPageSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetRowPage.v1"),
-  tasksetId: IdSchema,
-  tasksetRevision: z2.number().int().positive(),
-  artifactHash: HashSchema,
-  split: DatasetSplitSchema.nullable(),
-  rows: z2.array(z2.record(z2.string(), z2.unknown())).max(100),
-  nextCursor: z2.string().max(2e3).nullable(),
-  totalRows: z2.number().int().nonnegative(),
-  returnedRows: z2.number().int().nonnegative()
-});
-var DatasetStorageSettingsSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetStorageSettings.v1"),
-  datasetStorePath: z2.string().trim().min(1).max(4e3),
-  updatedAt: TimestampSchema
-});
-var DatasetStorageRootSchema = z2.object({
-  id: IdSchema,
-  label: z2.string().trim().min(1).max(500),
-  path: z2.string().trim().min(1).max(4e3),
-  datasetStorePath: z2.string().trim().min(1).max(4e3),
-  kind: z2.enum(["local", "network", "removable", "cache"]),
-  configured: z2.boolean(),
-  mounted: z2.boolean(),
-  writable: z2.boolean(),
-  totalBytes: z2.number().int().nonnegative().nullable(),
-  freeBytes: z2.number().int().nonnegative().nullable()
-});
-var DatasetStorageStateSchema = z2.object({
-  schemaVersion: z2.literal("openpond.datasetStorageState.v1"),
-  settings: DatasetStorageSettingsSchema,
-  storageRoots: z2.array(DatasetStorageRootSchema)
-});
-var UpdateDatasetStorageSettingsRequestSchema = z2.object({
-  datasetStorePath: z2.string().trim().min(1).max(4e3)
-});
-
-// src/taskset-draft-dataset-sources.ts
-import { z as z3 } from "zod";
-var IdSchema2 = z3.string().trim().min(1).max(240);
-var TimestampSchema2 = z3.string().trim().min(1);
-var HashSchema2 = z3.string().trim().min(8).max(256);
-var MetadataSchema = z3.record(z3.string(), z3.unknown()).default({});
-var RevisionSchema = z3.string().trim().min(7).max(256);
-var DatasetSourceReviewStatusSchema = z3.enum([
-  "pending",
-  "approved",
-  "review",
-  "blocked"
-]);
-var ExternalDatasetSourceBaseSchema = z3.object({
-  id: IdSchema2,
-  profileId: IdSchema2,
-  title: z3.string().trim().min(1).max(500),
-  sourceHash: HashSchema2,
-  occurredAt: TimestampSchema2,
-  licensingStatus: DatasetSourceReviewStatusSchema,
-  secretScanStatus: z3.enum(["pending", "passed", "blocked"]),
-  piiScanStatus: z3.enum(["pending", "passed", "review", "blocked"]),
-  metadata: MetadataSchema
-});
-var HuggingFaceDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z3.literal("openpond.huggingFaceDatasetSource.v1"),
-  kind: z3.literal("huggingface"),
-  repositoryId: z3.string().trim().regex(/^[^/\s]+\/[^/\s]+$/).max(500),
-  repositoryUrl: z3.string().url().max(2e3),
-  revision: RevisionSchema,
-  configuration: z3.string().trim().min(1).max(500),
-  upstreamSplits: z3.array(z3.string().trim().min(1).max(500)).min(1).max(1e3),
-  gated: z3.boolean(),
-  private: z3.boolean(),
-  declaredLicense: z3.string().trim().min(1).max(500).nullable(),
-  sourceFileHashes: z3.array(HashSchema2).min(1).max(1e5)
-});
-var UploadedFileDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z3.literal("openpond.uploadedFileDatasetSource.v1"),
-  kind: z3.literal("uploaded_file"),
-  originalFileNames: z3.array(z3.string().trim().min(1).max(500)).min(1).max(1e3),
-  mediaTypes: z3.array(z3.string().trim().min(1).max(200)).min(1).max(1e3),
-  sourceFileHashes: z3.array(HashSchema2).min(1).max(1e3),
-  totalBytes: z3.number().int().nonnegative(),
-  parserVersion: z3.string().trim().min(1).max(200)
-});
-var GeneratedDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z3.literal("openpond.generatedDatasetSource.v1"),
-  kind: z3.literal("generated"),
-  generatorId: IdSchema2,
-  generatorVersion: z3.string().trim().min(1).max(200),
-  seed: z3.number().int(),
-  generatorHash: HashSchema2
-});
-var LearningBatchDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
-  schemaVersion: z3.literal("openpond.learningBatchDatasetSource.v1"),
-  kind: z3.literal("learning_batch"),
-  batch: z3.object({ id: IdSchema2, revision: z3.number().int().positive(), contentHash: HashSchema2 }).strict(),
-  taskDefinition: z3.object({ id: IdSchema2, revision: z3.number().int().positive(), contentHash: HashSchema2 }).strict(),
-  admittedBy: IdSchema2
-});
-var ExternalDatasetSourceRefSchema = z3.discriminatedUnion("kind", [
-  HuggingFaceDatasetSourceRefSchema,
-  UploadedFileDatasetSourceRefSchema,
-  GeneratedDatasetSourceRefSchema,
-  LearningBatchDatasetSourceRefSchema
-]);
-
-// src/taskset-draft-harness-actions.ts
-import { z as z4 } from "zod";
-var HarnessActionBindingSchema = z4.object({
-  schemaVersion: z4.literal("openpond.harnessActionBinding.v1"),
-  actionId: ReleaseIdSchema,
-  modelToolName: z4.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
-  description: z4.string().trim().min(1).max(1e3),
-  inputSchema: z4.record(z4.string(), z4.unknown()),
-  actionSchemaHash: ReleaseHashSchema,
-  agentRelease: ImmutableReleaseRefSchema,
-  implementationHash: ReleaseHashSchema,
-  runtimeBindingId: ReleaseIdSchema,
-  capabilityReceiptHash: ReleaseHashSchema,
-  sideEffect: z4.enum(["read", "write"]),
-  studentVisible: z4.boolean(),
-  timeoutMs: z4.number().int().positive().max(36e5),
-  episodeArgumentBindings: z4.array(
-    z4.object({
-      argument: ReleaseIdSchema,
-      source: z4.literal("case_id")
-    }).strict()
-  ).max(20).default([])
-}).strict();
-
-// src/taskset-draft-core.ts
-import { z as z5 } from "zod";
-import { CustomVerifierRuntimeSchema } from "@openpond/evals/tasksets";
-import { HumanFormSchema } from "@openpond/evals/human-review";
-var IdSchema3 = z5.string().trim().min(1).max(240);
-var TimestampSchema3 = z5.string().trim().min(1);
-var HashSchema3 = z5.string().trim().min(8).max(256);
-var Sha256Schema = z5.string().trim().regex(/^[a-f0-9]{64}$/);
-var CodeIdentifierSchema = z5.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
-var MetadataSchema2 = z5.record(z5.string(), z5.unknown()).default({});
-var NullableIdSchema = IdSchema3.nullable();
-function safeRelativeFilePath(value) {
-  const normalized = value.trim().replaceAll("\\", "/");
-  if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
-    return false;
-  }
-  return !normalized.split("/").some(
-    (segment) => !segment || segment === "." || segment === ".."
-  );
-}
-function safeFileName(value) {
-  const normalized = value.trim();
-  return normalized.length > 0 && normalized !== "." && normalized !== ".." && !normalized.includes("/") && !normalized.includes("\\") && !normalized.includes("\0");
-}
-var TasksetSplitSchema = DatasetSplitSchema;
-var TasksetPurposeSchema = z5.enum(["general", "benchmark"]);
-var TasksetBenchmarkBindingSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetBenchmark.v1"),
-  definitionId: IdSchema3,
-  releaseId: IdSchema3,
-  releaseHash: Sha256Schema,
-  managedReleasePath: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
-  adaptationSplit: TasksetSplitSchema,
-  evaluationSplit: TasksetSplitSchema,
-  primaryMetric: z5.enum([
-    "foreground_tokens",
-    "success_rate",
-    "latency_ms",
-    "cost_usd"
-  ]),
-  qualityGate: z5.enum(["none", "non_regression", "all_pass"]),
-  source: z5.enum(["builtin", "imported"]),
-  metadata: MetadataSchema2
-});
-var TasksetPreferenceComparisonBindingSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
-  releaseId: IdSchema3,
-  releaseHash: Sha256Schema,
-  publishedAt: TimestampSchema3,
-  metadata: MetadataSchema2
-});
-var TrainingSourceConsentSchema = z5.object({
-  status: z5.enum(["pending", "granted", "denied", "revoked"]),
-  scope: z5.enum(["metadata_only", "selected_turns", "full_session"]),
-  grantedBy: NullableIdSchema,
-  grantedAt: TimestampSchema3.nullable(),
-  purpose: z5.literal("task_authoring_and_evaluation")
-});
-var TrainingSourceRefSchema = z5.object({
-  schemaVersion: z5.literal("openpond.trainingSource.v1"),
-  id: IdSchema3,
-  profileId: IdSchema3,
-  sessionId: IdSchema3,
-  turnIds: z5.array(IdSchema3).max(1e3).default([]),
-  workspaceId: NullableIdSchema,
-  sourceHash: HashSchema3,
-  clusterKey: IdSchema3,
-  title: z5.string().trim().min(1).max(500),
-  occurredAt: TimestampSchema3,
-  consent: TrainingSourceConsentSchema,
-  connectedAppIds: z5.array(IdSchema3).max(100).default([]),
-  secretScanStatus: z5.enum(["pending", "passed", "blocked"]),
-  piiScanStatus: z5.enum(["pending", "passed", "review", "blocked"]),
-  licensingStatus: z5.enum(["pending", "approved", "review", "blocked"]),
-  metadata: MetadataSchema2
-});
-var TasksetSourceRefSchema = z5.union([
-  TrainingSourceRefSchema,
-  ExternalDatasetSourceRefSchema,
-  ConnectedDatasetSourceRefSchema
-]);
-var TaskPolicyBoundarySchema = z5.object({
-  policyVisibleFields: z5.array(IdSchema3).max(1e3).default([]),
-  privilegedFields: z5.array(IdSchema3).max(1e3).default([]),
-  hiddenGraderRefs: z5.array(IdSchema3).max(100).default([]),
-  connectedAppScopes: z5.array(IdSchema3).max(100).default([])
-});
-var TaskAssetRefSchema = z5.object({
-  id: IdSchema3,
-  sourceRefId: IdSchema3,
-  artifactRef: z5.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
-  fileName: z5.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
-  stagingPath: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Task asset staging paths must stay inside Work inputs.").optional(),
-  mediaType: z5.string().trim().min(1).max(200),
-  sha256: Sha256Schema,
-  sizeBytes: z5.number().int().nonnegative().max(25e7),
-  split: TasksetSplitSchema,
-  metadata: MetadataSchema2
-}).superRefine((value, ctx) => {
-  if (value.stagingPath && value.stagingPath.split("/").at(-1) !== value.fileName)
-    ctx.addIssue({ code: "custom", message: "Staged task assets must preserve their source file name.", path: ["stagingPath"] });
-});
-var TaskRequiredOutputSchema = z5.object({
-  path: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
-  mediaType: z5.string().trim().min(1).max(200),
-  schemaRef: IdSchema3.nullable().optional(),
-  maxBytes: z5.number().int().positive().max(1e7).optional(),
-  metadata: MetadataSchema2
-});
-var TaskDataRecordSchema = z5.object({
-  schemaVersion: z5.literal("openpond.taskData.v1"),
-  id: IdSchema3,
-  clusterKey: IdSchema3,
-  split: TasksetSplitSchema,
-  input: z5.record(z5.string(), z5.unknown()),
-  expectedOutput: z5.record(z5.string(), z5.unknown()).nullable(),
-  policyVisibleContext: z5.record(z5.string(), z5.unknown()).default({}),
-  privilegedContextRef: NullableIdSchema,
-  sourceRefs: z5.array(IdSchema3).min(1).max(100),
-  assets: z5.array(TaskAssetRefSchema).max(1e3).optional(),
-  resourceRefs: z5.array(IdSchema3).max(1e3).optional(),
-  requiredOutputs: z5.array(TaskRequiredOutputSchema).max(100).optional(),
-  tags: z5.array(IdSchema3).max(100).default([]),
-  metadata: MetadataSchema2
-});
-var TasksetEnvironmentResourceSchema = z5.object({
-  id: IdSchema3,
-  kind: z5.enum(["file", "catalog", "configuration", "code_module"]),
-  path: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
-  mediaType: z5.string().trim().min(1).max(200).nullable().optional(),
-  visibility: z5.enum(["policy_visible", "policy_hidden", "privileged"]),
-  required: z5.boolean(),
-  metadata: MetadataSchema2
-});
-var LearningSignalBaseSchema = z5.object({
-  id: IdSchema3,
-  taskId: NullableIdSchema,
-  sourceRefs: z5.array(IdSchema3).min(1).max(100),
-  artifactRef: IdSchema3,
-  approved: z5.boolean(),
-  confidence: z5.number().min(0).max(1),
-  metadata: MetadataSchema2
-});
-var DemonstrationSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("demonstration"),
-  prompt: z5.string().max(1e5).nullable().default(null),
-  response: z5.string().max(2e5).nullable().default(null)
-});
-var PreferenceSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("preference"),
-  prompt: z5.string().max(1e5),
-  chosen: z5.string().max(2e5),
-  rejected: z5.string().max(2e5),
-  rationale: z5.string().max(1e5).nullable().default(null)
-});
-var CorrectionSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("correction"),
-  original: z5.string().max(2e5),
-  corrected: z5.string().max(2e5),
-  rationale: z5.string().max(1e5).nullable().default(null)
-});
-var FeedbackSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("feedback"),
-  feedback: z5.string().max(1e5),
-  polarity: z5.enum(["positive", "negative", "mixed", "neutral"])
-});
-var RewardSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("reward"),
-  task: z5.string().max(1e5),
-  rules: z5.array(z5.object({
-    id: IdSchema3,
-    points: z5.number().finite(),
-    condition: z5.string().trim().min(1).max(1e5)
-  })).min(1).max(1e3),
-  otherwisePoints: z5.number().finite(),
-  executable: z5.boolean()
-});
-var LabelSignalSchema = LearningSignalBaseSchema.extend({
-  kind: z5.literal("label"),
-  labelKind: z5.literal("rubric"),
-  task: z5.string().max(1e5),
-  criteria: z5.array(z5.object({
-    id: IdSchema3,
-    label: z5.string().trim().min(1).max(500),
-    description: z5.string().trim().min(1).max(1e5)
-  })).min(1).max(1e3),
-  calibrationExamples: z5.object({
-    positive: z5.string().trim().min(1).max(2e5),
-    negative: z5.string().trim().min(1).max(2e5),
-    boundary: z5.string().trim().min(1).max(2e5)
-  })
-});
-var LearningSignalRefSchema = z5.discriminatedUnion("kind", [
-  DemonstrationSignalSchema,
-  PreferenceSignalSchema,
-  CorrectionSignalSchema,
-  FeedbackSignalSchema,
-  RewardSignalSchema,
-  LabelSignalSchema
-]);
-var LearningSignalInventorySchema = z5.object({
-  demonstrations: z5.array(DemonstrationSignalSchema).max(1e5).default([]),
-  preferences: z5.array(PreferenceSignalSchema).max(1e5).default([]),
-  corrections: z5.array(CorrectionSignalSchema).max(1e5).default([]),
-  feedback: z5.array(FeedbackSignalSchema).max(1e5).default([]),
-  rewards: z5.array(RewardSignalSchema).max(1e5).default([]),
-  labels: z5.array(LabelSignalSchema).max(1e5).default([])
-});
-var TasksetEnvironmentContractSchema = z5.object({
-  protocolVersion: z5.literal("openpond.taskEnvironment.v1"),
-  kind: z5.enum(["chat", "agent", "program", "stateful_harness", "work"]),
-  entrypoint: z5.string().trim().min(1).max(1e3),
-  stateful: z5.boolean(),
-  deterministicSeeds: z5.boolean(),
-  toolNames: z5.array(IdSchema3).max(200).default([]),
-  actionBindings: z5.array(HarnessActionBindingSchema).max(200).optional(),
-  lifecycle: z5.array(z5.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
-  defaultTimeoutMs: z5.number().int().positive().max(36e5),
-  networkPolicy: z5.enum(["none", "declared_read_only", "declared_scoped"]),
-  resources: z5.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
-  metadata: MetadataSchema2
-});
-var TasksetCapabilityManifestSchema = z5.object({
-  schemaVersion: z5.literal("openpond.tasksetCapabilities.v1"),
-  taskKind: z5.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
-  supportedSignals: z5.array(z5.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
-  compatibleMethods: z5.array(z5.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
-  rewardKinds: z5.array(z5.enum(["none", "exact", "deterministic", "model_judge", "human"])),
-  requiresTools: z5.boolean(),
-  requiresState: z5.boolean(),
-  requiresPrivilegedGrading: z5.boolean(),
-  environmentPlacements: z5.array(z5.enum(["local", "remote", "colocated", "provider_native"])),
-  exportable: z5.boolean(),
-  portabilityBlockers: z5.array(z5.string().trim().min(1).max(2e3)).default([])
-});
-var GraderBaseSchema = z5.object({
-  id: IdSchema3,
-  taskIds: z5.array(IdSchema3).min(1).max(1e4).refine((ids) => new Set(ids).size === ids.length, "Grader task IDs must be unique.").optional(),
-  version: z5.string().trim().min(1).max(100),
-  label: z5.string().trim().min(1).max(500),
-  weight: z5.number().min(0).max(1e3).default(1),
-  hardGate: z5.boolean().default(false),
-  rewardEligible: z5.boolean().default(false),
-  privileged: z5.boolean().default(false),
-  metadata: MetadataSchema2
-});
-var DeterministicGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
-  config: z5.record(z5.string(), z5.unknown())
-});
-var RubricGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.literal("model_judge"),
-  rubric: z5.string().trim().min(1).max(5e4),
-  judge: ChatModelRefSchema,
-  calibrationFixtureRefs: z5.array(IdSchema3).min(1).max(500),
-  calibrationStatus: z5.enum(["pending", "passed", "failed"]),
-  temperature: z5.number().min(0).max(2).default(0)
-});
-var HumanGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.literal("human"),
-  form: HumanFormSchema.optional(),
-  rubric: z5.string().trim().min(1).max(5e4),
-  reviewerRole: z5.string().trim().min(1).max(500)
-});
-var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
-  kind: z5.literal("custom_verifier"),
-  runtime: CustomVerifierRuntimeSchema.optional(),
-  module: z5.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
-  exportName: CodeIdentifierSchema,
-  timeoutMs: z5.number().int().positive().max(3e5),
-  networkPolicy: z5.literal("none")
-});
-var GraderSpecSchema = z5.union([
-  DeterministicGraderSpecSchema,
-  RubricGraderSpecSchema,
-  HumanGraderSpecSchema,
-  CustomVerifierGraderSpecSchema
-]);
-var GraderFixtureLabelSchema = z5.enum([
-  "positive",
-  "negative",
-  "boundary",
-  "adversarial",
-  "prompt_injection",
-  "infrastructure_failure"
-]);
-var GraderFixtureSchema = z5.object({
-  id: IdSchema3,
-  taskId: IdSchema3,
-  label: GraderFixtureLabelSchema,
-  output: z5.record(z5.string(), z5.unknown()),
-  infrastructureError: z5.string().trim().min(1).max(1e4).nullable(),
-  expectedPassed: z5.boolean(),
-  expectedRewardEligible: z5.boolean(),
-  metadata: MetadataSchema2
-});
-
-// src/model-starter-execution.ts
-import { z as z6 } from "zod";
-import { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from "@openpond/evals";
-import { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from "@openpond/evals/javascript-environment/contracts";
-import { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset } from "@openpond/evals/learning";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-import {
-  NativeHarnessExperimentAttemptSchema,
-  verifyNativeHarnessExperimentAttempt
-} from "@openpond/evals/experiments";
-var HashSchema4 = z6.string().regex(/^[a-f0-9]{64}$/);
-var ModelStarterEnvironmentAttemptSchema = /* @__PURE__ */ (() => z6.object({
-  schemaVersion: z6.literal("openpond.javascriptEnvironmentAttempt.v1"),
-  taskId: z6.string(),
-  status: z6.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
-  output: z6.string().nullable(),
-  collected: z6.boolean(),
-  environmentCleanupComplete: z6.boolean(),
-  snapshot: z6.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema4, seed: z6.number().int(), initialStateHash: HashSchema4, finalStateHash: HashSchema4, state: z6.record(z6.string(), z6.unknown()), events: z6.array(z6.record(z6.string(), z6.unknown())) }).strict().nullable(),
-  messages: z6.array(z6.unknown()),
-  error: z6.string().nullable(),
-  contentHash: HashSchema4
-}).strict())();
-function verifyModelStarterEnvironmentAttempt(value, context) {
-  assertBoundedTaskJson(value, 16777216);
-  const result = ModelStarterEnvironmentAttemptSchema.parse(value);
-  const { contentHash: contentHash2, ...content } = result;
-  if (sealLearningContent(content).contentHash !== contentHash2 || result.taskId !== context.taskId || result.snapshot && (!equal(result.snapshot.definition, context.javascript) || result.snapshot.inputHash !== sealLearningContent(context.input).contentHash || result.snapshot.seed !== context.seed || result.snapshot.finalStateHash !== sealLearningContent(result.snapshot.state).contentHash)) throw new Error("Starter environment attempt differs from its admitted task or recorded bytes.");
-  return result;
-}
-var ModelStarterExecutionSchema = z6.object({
-  environment: EnvironmentReleaseSchema,
-  verifierSet: VerifierSetReleaseSchema,
-  javascript: JavaScriptEnvironmentDefinitionSchema
-}).strict();
-var ModelStarterToolFixtureScriptSchema = z6.object({
-  actions: z6.array(z6.object({ name: z6.string().min(1).max(64), arguments: z6.record(z6.string(), z6.unknown()) }).strict()).max(1e3)
-}).strict();
-function modelStarterExecutionAssetId(context) {
-  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Starter execution release references are missing.");
-  return `starter-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
-}
-function createModelStarterExecutionAsset(value) {
-  const execution = ModelStarterExecutionSchema.parse(value);
-  assertExecutionIntegrity(execution);
-  const id = modelStarterExecutionAssetId({ environmentRelease: { id: execution.environment.id, contentHash: execution.environment.contentHash }, verifierSetRelease: { id: execution.verifierSet.id, contentHash: execution.verifierSet.contentHash } });
-  const generated = createLearningTextAsset({ text: canonicalJson(execution), path: "environment/execution.json", mediaType: "application/json", visibility: "host_private" });
-  const { contentHash: _hash, ...content } = generated;
-  return sealLearningContent({ ...content, id, asset: { ...content.asset, id } });
-}
-function resolveModelStarterExecutionAsset(context, asset, assets) {
-  if (asset.id !== modelStarterExecutionAssetId(context) || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") throw new Error("Starter execution asset differs from its Taskset references.");
-  const execution = ModelStarterExecutionSchema.parse(JSON.parse(verifyLearningTextAsset(asset, asset.asset)));
-  validateModelStarterExecution(execution, context, assets);
-  return execution;
-}
-function equal(left, right) {
-  return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;
-}
-function assertExecutionIntegrity(execution) {
-  assertJavaScriptEnvironmentDefinition(execution.javascript);
-  for (const resource of [execution.environment, execution.verifierSet]) {
-    const { contentHash: contentHash2, ...content } = resource;
-    if (sealLearningContent(content).contentHash !== contentHash2) throw new Error(`Starter execution resource integrity failed: ${resource.id}.`);
-  }
-  if (!equal(execution.environment.metadata.javascriptEnvironment, learningRef(execution.javascript))) throw new Error("Starter execution resources differ from its declared task context.");
-}
-function validateModelStarterExecution(execution, taskset, assets) {
-  if (!execution) {
-    if (taskset.environment.entrypoint === "openpond.javascript-environment.v1") throw new Error("Starter JavaScript execution resources are missing.");
-    return;
-  }
-  const { environment, verifierSet, javascript } = execution;
-  assertExecutionIntegrity(execution);
-  if (!equal(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !equal(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !equal(environment.contract, taskset.environment) || !equal(verifierSet.graders, taskset.graders) || !equal(taskset.tools, javascript.tools) || !equal(environment.metadata.javascriptEnvironment, learningRef(javascript))) {
-    throw new Error("Starter execution resources differ from its declared task context.");
-  }
-  const contract = environment.contract;
-  if (contract.entrypoint !== "openpond.javascript-environment.v1" || contract.kind !== "agent" || !contract.stateful || !contract.deterministicSeeds || contract.networkPolicy !== "none" || new Set(contract.lifecycle).size !== 5 || taskset.capabilities.length || taskset.policy.connectedAppScopes.length) {
-    throw new Error("Starter JavaScript environment declares unsupported host capabilities.");
-  }
-  for (const reference of [javascript.module, environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) {
-    if (!reference) continue;
-    const asset = assets.find((asset2) => asset2.id === reference.id);
-    if (!asset) throw new Error(`Starter environment asset is missing: ${reference.id}.`);
-    verifyLearningTextAsset(asset, reference);
-  }
-  for (const task of taskset.tasks) {
-    const asset = assets.find((asset2) => asset2.id === task.privilegedContextRef);
-    if (!asset || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") {
-      throw new Error(`Starter private initial state is missing: ${task.id}.`);
-    }
-    const state = JSON.parse(verifyLearningTextAsset(asset, asset.asset));
-    if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error(`Starter initial state must be a JSON object: ${task.id}.`);
-    assertBoundedTaskJson(state, javascript.maxStateBytes);
-  }
-}
-
-// src/model-taskset-resources.ts
-import { z as z7 } from "zod";
-import { EnvironmentReleaseSchema as EnvironmentReleaseSchema2, VerifierSetReleaseSchema as VerifierSetReleaseSchema2, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
-import { createLearningTextAsset as createLearningTextAsset2, sealLearningContent as sealLearningContent2, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
-var ModelTasksetExecutionResourcesSchema = z7.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
-function modelTasksetExecutionResourcesAssetId(context) {
-  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Taskset execution references are missing.");
-  return `taskset-execution-${sealLearningContent2({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
-}
-function createModelTasksetExecutionResourcesAsset(value) {
-  const resources = ModelTasksetExecutionResourcesSchema.parse({ environment: value.environment, verifierSet: value.verifierSet });
-  assertIntegrity(resources);
-  const id = modelTasksetExecutionResourcesAssetId({ environmentRelease: { id: resources.environment.id, contentHash: resources.environment.contentHash }, verifierSetRelease: { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash } });
-  const { contentHash: _hash, ...asset } = createLearningTextAsset2({ text: canonicalJson(resources), path: "environment/resources.json", mediaType: "application/json", visibility: "host_private" });
-  return sealLearningContent2({ ...asset, id, asset: { ...asset.asset, id } });
-}
-function resolveModelTasksetExecutionResourcesAsset(context, asset) {
-  if (asset.id !== modelTasksetExecutionResourcesAssetId(context) || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") throw new Error("Taskset execution asset differs from its published references.");
-  const resources = ModelTasksetExecutionResourcesSchema.parse(JSON.parse(verifyLearningTextAsset2(asset, asset.asset)));
-  assertIntegrity(resources);
-  if (asset.id !== createModelTasksetExecutionResourcesAsset(resources).id || canonicalJson(context.environment) !== canonicalJson(resources.environment.contract) || canonicalJson(context.graders) !== canonicalJson(resources.verifierSet.graders)) throw new Error("Taskset differs from its execution resources.");
-  return resources;
-}
-function assertIntegrity(resources) {
-  if (!verifyEnvironmentRelease(resources.environment) || !verifyVerifierSetRelease(resources.verifierSet)) throw new Error("Taskset execution resource integrity failed.");
-}
-
-// src/model-taskset-derivation.ts
-import { z as z8 } from "zod";
-import { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease as verifyEnvironmentRelease2, verifyVerifierSetRelease as verifyVerifierSetRelease2 } from "@openpond/evals";
-import { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
-import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
-import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
-import { validateTaskValue } from "@openpond/evals/task-schema";
-var OwnerSchema = z8.object({ scopeId: z8.string().trim().min(1).max(500), modelId: z8.string().trim().min(1).max(500) }).strict();
-var ModelTasksetDerivationSchema = z8.object({
-  schemaVersion: z8.literal("openpond.modelTasksetDerivation.v1"),
-  owner: OwnerSchema,
-  root: ModelProjectVersionedRefSchema,
-  parent: ModelProjectVersionedRefSchema
-}).strict();
-var ModelTasksetPackageSchema = z8.object({
-  taskset: TasksetReleaseSchema,
-  taskDefinition: TaskDefinitionSchema,
-  rewardBinding: RewardBindingSchema,
-  rewards: z8.array(RewardReleaseSchema).min(1).max(100),
-  assets: z8.array(LearningTextAssetSchema).max(1e3),
-  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
-  execution: ModelStarterExecutionSchema.optional(),
-  instructionMode: z8.literal("per_task").optional()
-}).strict();
-var same = (left, right) => sealLearningContent3({ value: left }).contentHash === sealLearningContent3({ value: right }).contentHash;
-var identity = (owner, root) => `model-taskset-${sealLearningContent3({ owner, root }).contentHash}`;
-function deriveModelTaskset(input) {
-  return compileModelTasksetReward({ ...input, source: validateModelTasksetPackage(input.source) });
-}
-function compileModelTasksetReward(input) {
-  const owner = OwnerSchema.parse(input.owner);
-  const source = input.source;
-  const edited = input.edits ?? source;
-  const previous = source.taskset.metadata.modelTasksetDerivation === void 0 ? null : ModelTasksetDerivationSchema.parse(source.taskset.metadata.modelTasksetDerivation);
-  if (previous && source.taskset.id !== identity(previous.owner, previous.root)) throw new Error("Derived Taskset identity differs from its ownership lineage.");
-  const owned = previous && same(previous.owner, owner);
-  const root = owned ? previous.root : learningRef2(source.taskset);
-  const id = owned ? source.taskset.id : identity(owner, root);
-  const revision = owned ? source.taskset.revision + 1 : 1;
-  const rewardBinding = RewardBindingSchema.parse(input.rewardBinding);
-  const rewards = input.rewards.map((reward) => RewardReleaseSchema.parse(reward));
-  const graders = compileBoundGraders(rewardBinding, rewards);
-  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
-  const policy = { ...edited.taskset.policy, hiddenGraderRefs: graders.filter((grader) => grader.privileged).map((grader) => grader.id) };
-  const previousResources = edited.executionResources ?? edited.execution;
-  const environment = previousResources?.environment ?? createEnvironmentRelease({
-    schemaVersion: "openpond.environmentRelease.v1",
-    id: `${id}-environment`,
-    revision: 1,
-    contract: edited.taskset.environment,
-    actionSchemaRef: null,
-    observationSchemaRef: null,
-    stateSchemaRef: null,
-    artifactCollection: { maxArtifacts: 1e5, maxTotalBytes: 25e7 },
-    adapterConformanceHashes: {},
-    metadata: {}
-  });
-  const verifierSet = createVerifierSetRelease({
-    schemaVersion: "openpond.verifierSetRelease.v1",
-    id: `${id}-verifiers`,
-    revision,
-    graders,
-    isolation: previousResources?.verifierSet.isolation ?? { processBoundary: "isolated_process", networkPolicy: "none", defaultTimeoutMs: Math.min(edited.taskset.environment.defaultTimeoutMs, 3e5) },
-    calibrationReceiptRefs: [],
-    metadata: previousResources ? { sourceVerifierSet: learningRef2(previousResources.verifierSet) } : {}
-  });
-  const executionResources = { environment, verifierSet };
-  const execution = edited.execution ? { ...edited.execution, verifierSet } : void 0;
-  const { contentHash: _taskHash, ...taskContent } = edited.taskset;
-  const { contentHash: _definitionHash, ...definitionContent } = edited.taskDefinition;
-  const taskExecution = { ...definitionContent.execution, policy, environmentRelease: { id: environment.id, contentHash: environment.contentHash }, verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash } };
-  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent3({ ...definitionContent, id: `${id}-definition`, revision, rewardBinding: learningRef2(rewardBinding), execution: taskExecution }));
-  const authoring = source.taskset.metadata.starterAuthoring ?? source.taskset.metadata.ordinaryAuthoring;
-  const graderFixtures = authoring && typeof authoring === "object" && !Array.isArray(authoring) && "graderFixtures" in authoring ? authoring.graderFixtures : void 0;
-  const taskset = TasksetReleaseSchema.parse(sealLearningContent3({
-    ...taskContent,
-    ...taskExecution,
-    id,
-    revision,
-    graders,
-    metadata: {
-      starter: { taskDefinition: learningRef2(taskDefinition), rewardBinding: learningRef2(rewardBinding) },
-      rewardExecution: { binding: rewardBinding, rewards },
-      ...graderFixtures === void 0 ? {} : { starterAuthoring: { graderFixtures } },
-      ...edited.taskset.metadata.environmentResources === void 0 ? {} : { environmentResources: edited.taskset.metadata.environmentResources },
-      ...edited.taskset.metadata.workAssetStagingPaths === void 0 ? {} : { workAssetStagingPaths: edited.taskset.metadata.workAssetStagingPaths },
-      ...edited.taskset.metadata.tasksetOutputContract === void 0 ? {} : { tasksetOutputContract: edited.taskset.metadata.tasksetOutputContract },
-      modelTasksetDerivation: { schemaVersion: "openpond.modelTasksetDerivation.v1", owner, root, parent: learningRef2(source.taskset) }
-    }
-  }));
-  return validateModelTasksetPackage({ taskset, taskDefinition, rewardBinding, rewards, assets: input.assets, executionResources, ...execution ? { execution } : {}, ...source.instructionMode ? { instructionMode: source.instructionMode } : {} });
-}
-function validateModelTasksetPackage(value) {
-  const result = ModelTasksetPackageSchema.parse(value);
-  const { taskset, taskDefinition, rewardBinding, rewards, assets, execution } = result;
-  for (const resource of [taskset, taskDefinition, rewardBinding, ...rewards, ...assets]) assertLearningContentHash(resource);
-  assertTasksetRelease(taskset);
-  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
-  if (!sameLearningRef(taskDefinition.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset definition differs from its Reward binding.");
-  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
-  if (!same(taskDefinition.execution, { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} })) throw new Error("Taskset definition differs from its execution resources.");
-  if (!same(taskset.graders, compileBoundGraders(rewardBinding, rewards))) throw new Error("Taskset graders differ from its Reward binding.");
-  if (taskset.metadata.starter !== void 0) {
-    const metadata = z8.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);
-    if (!sameLearningRef(metadata.taskDefinition, learningRef2(taskDefinition)) || !sameLearningRef(metadata.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset metadata differs from its immutable grading resources.");
-  }
-  if (taskset.metadata.rewardExecution !== void 0 && !same(taskset.metadata.rewardExecution, { binding: rewardBinding, rewards })) throw new Error("Taskset embedded Rewards differ from its immutable grading resources.");
-  if (taskset.metadata.rewardBinding !== void 0 && !sameLearningRef(ModelProjectVersionedRefSchema.parse(taskset.metadata.rewardBinding), learningRef2(rewardBinding))) throw new Error("Taskset Reward reference differs from its immutable grading resources.");
-  const resources = result.executionResources ?? execution;
-  if (taskset.environmentRelease && !resources) throw new Error("Deriving a Taskset requires its pinned execution resources.");
-  if (resources && (!verifyEnvironmentRelease2(resources.environment) || !verifyVerifierSetRelease2(resources.verifierSet) || !same(taskset.environmentRelease, { id: resources.environment.id, contentHash: resources.environment.contentHash }) || !same(taskset.verifierSetRelease, { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash }) || !same(taskset.environment, resources.environment.contract) || !same(taskset.graders, resources.verifierSet.graders))) throw new Error("Taskset differs from its pinned execution resources.");
-  validateModelStarterExecution(execution, taskset, assets);
-  if (new Set(assets.map((asset) => asset.id)).size !== assets.length) throw new Error("Taskset asset identities must be unique.");
-  for (const asset of assets) verifyLearningTextAsset3(asset, asset.asset);
-  for (const reference of resources ? [resources.environment.actionSchemaRef, resources.environment.observationSchemaRef, resources.environment.stateSchemaRef] : []) {
-    if (!reference) continue;
-    const asset = assets.find((asset2) => asset2.id === reference.id);
-    if (!asset) throw new Error(`Taskset environment asset is missing: ${reference.id}.`);
-    verifyLearningTextAsset3(asset, reference);
-  }
-  for (const task of taskset.tasks) {
-    if (taskDefinition.requiredOutputs && !same(task.requiredOutputs, taskDefinition.requiredOutputs)) throw new Error(`Taskset outputs differ from its reviewed definition: ${task.id}.`);
-    if (result.instructionMode !== "per_task" && task.policyVisibleContext.instructions !== taskDefinition.instructions || !validateTaskValue(taskDefinition.inputSchema, task.input).valid || task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Taskset task differs from its declared format: ${task.id}.`);
-    if (task.privilegedContextRef && !assets.some((asset) => asset.id === task.privilegedContextRef && asset.asset.visibility === "host_private")) throw new Error(`Taskset private context is missing: ${task.id}.`);
-  }
-  for (const reward of rewards) {
-    const implementation = reward.implementation;
-    const references = [...reward.assets, ..."verifierRef" in implementation ? [implementation.verifierRef] : [], ..."rubricRef" in implementation ? [implementation.rubricRef] : [], ..."inputContract" in implementation ? [implementation.inputContract] : []];
-    for (const reference of references) {
-      const asset = assets.find((asset2) => asset2.id === reference.id);
-      if (!asset || reference.visibility === "policy") throw new Error(`Taskset Reward requires its private asset: ${reference.id}.`);
-      verifyLearningTextAsset3(asset, reference);
-    }
-  }
-  return result;
-}
-
-// src/taskset-package-learning.ts
-import { z as z9 } from "zod";
-import {
-  TaskBatchSchema,
-  TaskEvidenceSchema,
-  TaskAdmissionDecisionSchema,
-  LearningSourceSchema,
-  LearningTextAssetSchema as LearningTextAssetSchema2,
-  assertLearningContentHash as assertLearningContentHash2,
-  compileTaskBatch,
-  learningRef as learningRef3,
-  sameLearningRef as sameLearningRef2,
-  taskBatchPackageMetadata,
-  verifyLearningTextAsset as verifyLearningTextAsset4
-} from "@openpond/evals/learning";
-var TasksetPackageLearningResourcesSchema = z9.object({
-  batch: TaskBatchSchema,
-  evidence: z9.array(TaskEvidenceSchema).min(1).max(1e4),
-  decisions: z9.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
-  sources: z9.array(LearningSourceSchema).min(1).max(1e4),
-  assets: z9.array(LearningTextAssetSchema2).max(1e3)
-}).strict();
-function learningPackageContextFiles(resources) {
-  return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
-    const text = canonicalJson(evidence.submission.evaluatorContext);
-    const bytes = new TextEncoder().encode(text);
-    return {
-      asset: {
-        id: `task-evidence:${evidence.contentHash}`,
-        path: `learning/context/${evidence.contentHash}.json`,
-        contentHash: sha256(bytes),
-        sizeBytes: bytes.byteLength,
-        mediaType: "application/json",
-        visibility: "host_private"
-      },
-      base64: btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""))
-    };
-  });
-}
-function validateTasksetLearningResources(taskset, input) {
-  const resources = TasksetPackageLearningResourcesSchema.parse(input);
-  const metadata = taskBatchPackageMetadata(taskset);
-  if (!sameLearningRef2(learningRef3(resources.batch), metadata.batch)) throw new Error("Taskset learning batch differs from its admission metadata.");
-  for (const collection of [resources.evidence, resources.decisions, resources.sources, resources.assets]) {
-    const identities = /* @__PURE__ */ new Set();
-    for (const resource of collection) {
-      assertLearningContentHash2(resource);
-      const key = `${resource.id}:${resource.revision}`;
-      if (identities.has(key)) throw new Error("Taskset learning resource identities must be unique.");
-      identities.add(key);
-    }
-  }
-  if (resources.evidence.length !== resources.batch.examples.length || resources.decisions.length !== resources.batch.examples.length) throw new Error("Taskset learning snapshots must match the admitted batch inventory.");
-  for (const evidence of resources.evidence) {
-    const source = resources.sources.find((source2) => sameLearningRef2(learningRef3(source2), evidence.source));
-    if (!source || !sameLearningRef2(source.taskDefinition, learningRef3(metadata.definition))) throw new Error("Taskset evidence source differs from its task definition.");
-  }
-  if (resources.sources.some((source) => !resources.evidence.some((evidence) => sameLearningRef2(evidence.source, learningRef3(source))))) throw new Error("Taskset package includes an unrelated learning source.");
-  const rewardAssets = metadata.rewards.flatMap((reward) => [
-    ...reward.assets,
-    ...reward.implementation.kind === "custom_verifier" ? [reward.implementation.verifierRef] : reward.implementation.kind === "model_judge" || reward.implementation.kind === "human" ? [reward.implementation.rubricRef] : [],
-    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
-  ]);
-  for (const ref of rewardAssets) {
-    const asset = resources.assets.find((asset2) => asset2.id === ref.id);
-    if (!asset) throw new Error("Taskset learning Reward asset is missing.");
-    verifyLearningTextAsset4(asset, ref);
-  }
-  if (resources.assets.some((asset) => !rewardAssets.some((ref) => ref.id === asset.id))) throw new Error("Taskset package includes an unrelated learning asset.");
-  const compiled = compileTaskBatch({
-    batch: resources.batch,
-    definition: metadata.definition,
-    binding: metadata.binding,
-    rewards: metadata.rewards,
-    evidence: resources.evidence,
-    decisions: resources.decisions
-  });
-  const compiledMetadata = taskBatchPackageMetadata(compiled);
-  if (contentHash(compiledMetadata) !== contentHash(metadata)) throw new Error("Taskset admission metadata differs from its reviewed snapshots.");
-  const execution = (release) => ({ policy: release.policy, environment: release.environment, tools: release.tools });
-  if (contentHash(execution(compiled)) !== contentHash(execution(taskset))) throw new Error("Taskset execution differs from its reviewed task definition.");
-  const taskContent = (task) => ({
-    id: task.id,
-    clusterKey: task.clusterKey,
-    split: task.split,
-    input: task.input,
-    expectedOutput: task.expectedOutput,
-    policyVisibleContext: task.policyVisibleContext,
-    privilegedContextRef: task.privilegedContextRef,
-    artifactRefs: task.artifactRefs,
-    requiredOutputs: task.requiredOutputs ?? [],
-    tags: task.tags
-  });
-  if (contentHash(compiled.tasks.map(taskContent)) !== contentHash(taskset.tasks.map(taskContent))) throw new Error("Taskset rows differ from their reviewed evidence.");
-  return resources;
-}
-
-// src/taskset-package-files.ts
-import { z as z10 } from "zod";
-var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z10.object({
-  asset: ImmutableAssetRefSchema,
-  base64: z10.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
-}).strict();
-function decodeTasksetPackageFile(value) {
-  const file = TasksetPackageFileSchema.parse(value);
-  const raw = atob(file.base64);
-  if (btoa(raw) !== file.base64) throw new Error(`Taskset asset ${file.asset.id} has noncanonical base64.`);
-  const bytes = new Uint8Array(raw.length);
-  for (let index = 0; index < raw.length; index++) bytes[index] = raw.charCodeAt(index);
-  if (bytes.byteLength !== file.asset.sizeBytes || sha256(bytes) !== file.asset.contentHash) throw new Error(`Taskset asset ${file.asset.id} differs from its immutable bytes.`);
-  return bytes;
-}
-
-// src/taskset-package-execution.ts
-import { LearningTextAssetSchema as LearningTextAssetSchema3, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
-function resolveTasksetPackageExecution(input) {
-  if (input.taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return null;
-  const byId = new Map(input.files.map((file) => [file.asset.id, file]));
-  const read = (id) => {
-    const file = byId.get(id);
-    if (!file) throw new Error(`Taskset environment asset is missing: ${id}.`);
-    if (file.asset.sizeBytes > 524288) throw new Error("Taskset environment source exceeds the authored asset limit.");
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-    return LearningTextAssetSchema3.parse(sealLearningContent4({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text }));
-  };
-  let execution;
-  if (input.modelResources) {
-    if (!input.modelResources.execution) throw new Error("Bound Taskset JavaScript execution resources are missing.");
-    execution = ModelStarterExecutionSchema.parse(input.modelResources.execution);
-  } else {
-    const declaration = read(modelStarterExecutionAssetId(input.taskset));
-    if (declaration.asset.visibility !== "host_private" || declaration.asset.mediaType !== "application/json" || declaration.asset.path !== "environment/execution.json") throw new Error("Taskset execution declaration must be private JSON at environment/execution.json.");
-    execution = ModelStarterExecutionSchema.parse(JSON.parse(declaration.text));
-  }
-  const ids = /* @__PURE__ */ new Set([
-    execution.javascript.module.id,
-    ...[execution.environment.actionSchemaRef, execution.environment.observationSchemaRef, execution.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : []),
-    ...input.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : [])
-  ]);
-  const assets = [...ids].map(read);
-  validateModelStarterExecution(execution, input.taskset, assets);
-  return { execution, assets };
-}
-function createTasksetPackageExecutionFile(execution) {
-  const asset = createModelStarterExecutionAsset(execution);
-  const bytes = new TextEncoder().encode(asset.text);
-  let raw = "";
-  for (const byte of bytes) raw += String.fromCharCode(byte);
-  return { asset: asset.asset, base64: btoa(raw) };
-}
-
-// src/taskset-calibration-fixtures.ts
-import { z as z11 } from "zod";
-import { compileBoundGraders as compileBoundGraders2, createRewardBinding, RewardReleaseRefSchema } from "@openpond/evals/rewards";
-import { TaskRecordSchema } from "@openpond/evals/tasksets";
-import {
-  learningRef as learningRef4,
-  LearningRevisionRefSchema,
-  RewardFixtureSchema,
-  verifyRewardCalibrationClosure,
-  rewardCalibrationClosureAsset,
-  MAX_REWARD_CALIBRATION_CLOSURE_BYTES
-} from "@openpond/evals/learning/reward-calibration-closure";
-var ProjectionSchema = z11.object({
-  schemaVersion: z11.literal("openpond.connectedRewardCalibrationProjection.v1"),
-  sourceReward: RewardReleaseRefSchema,
-  fixtureSet: ImmutableAssetRefSchema,
-  calibrationCheck: LearningRevisionRefSchema,
-  fixture: RewardFixtureSchema,
-  fixtureHash: z11.string().regex(/^[a-f0-9]{64}$/),
-  checkResultHash: z11.string().regex(/^[a-f0-9]{64}$/),
-  independentCalibrationTask: z11.literal(true),
-  closureRef: ImmutableAssetRefSchema,
-  graderId: z11.string().min(1).max(240).optional()
-}).strict();
-function authoredFixtures(value) {
-  const authoring = value.taskset.metadata.ordinaryAuthoring ?? value.taskset.metadata.starterAuthoring;
-  return z11.object({ graderFixtures: GraderFixtureSchema.array().max(1e5).default([]) }).passthrough().parse(authoring ?? {}).graderFixtures;
-}
-function isIndependent(fixture) {
-  const projection = fixture.metadata.rewardCalibration;
-  return projection !== void 0;
-}
-function assertTasksetCalibrationClosures(value) {
-  for (const fixture of authoredFixtures(value)) {
-    const projection = fixture.metadata.rewardCalibration;
-    if (projection && typeof projection === "object" && Object.hasOwn(projection, "closureRef"))
-      resolveIndependent(value, fixture);
-  }
-  for (const file of value.files) if (file.asset.mediaType === "application/vnd.openpond.reward-calibration-closure+json")
-    readPrivateClosure(value, file.asset);
-}
-function resolveTasksetCalibrationFixture(value, fixtureId) {
-  const { contentHash: packageHash, ...packageContent } = value;
-  if (contentHash(packageContent) !== packageHash) fail("calibration_package_changed");
-  const fixtures = authoredFixtures(value).filter((fixture2) => fixture2.id === fixtureId);
-  if (fixtures.length !== 1) fail("calibration_fixture_not_unique");
-  const fixture = fixtures[0];
-  if (!isIndependent(fixture)) fail("calibration_fixture_not_independent");
-  return resolveIndependent(value, fixture);
-}
-function resolveIndependent(value, authored) {
-  const projection = ProjectionSchema.parse(authored.metadata.rewardCalibration);
-  const closure = readPrivateClosure(value, projection.closureRef);
-  if (contentHash(projection.sourceReward) !== contentHash(learningRef4(closure.reward)) || contentHash(projection.fixtureSet) !== contentHash(closure.reward.fixtureSetRef) || projection.calibrationCheck.id !== closure.check.id || projection.calibrationCheck.revision !== closure.check.revision || projection.calibrationCheck.contentHash !== contentHash(closure.check)) fail("calibration_source_changed");
-  const fixture = projection.fixture;
-  const id = `calibration-${contentHash([projection.sourceReward, fixture.id])}`;
-  if (authored.id !== id || authored.taskId !== id || value.taskset.tasks.some((task) => task.id === id) || projection.fixtureHash !== contentHash(fixture) || contentHash(authored.output) !== contentHash(fixture.output) || authored.infrastructureError !== fixture.infrastructureError) fail("calibration_fixture_changed");
-  const checks = closure.check.results.filter((result) => result.fixture.id === fixture.id && result.fixture.contentHash === projection.fixtureHash);
-  if (checks.length !== 1 || contentHash(checks[0]) !== projection.checkResultHash) fail("calibration_result_changed");
-  const expected = fixture.expected;
-  if (expected.status !== "scored" || typeof expected.passed !== "boolean" || authored.expectedPassed !== expected.passed || authored.label !== (expected.passed ? "positive" : "negative")) fail("calibration_expectation_unsupported");
-  const graderId = projection.graderId ?? projection.sourceReward.id;
-  const graders = value.taskset.graders.filter((grader2) => grader2.id === graderId);
-  const grader = graders[0];
-  if (graders.length !== 1 || !grader) fail("calibration_grader_not_unique");
-  if (authored.expectedRewardEligible !== grader.rewardEligible) fail("calibration_reward_expectation_changed");
-  const binding = createRewardBinding({
-    schemaVersion: "openpond.rewardBinding.v1",
-    id: `calibration-${closure.contentHash}`,
-    revision: 1,
-    sources: [{
-      graderId,
-      reward: projection.sourceReward,
-      role: "evaluation",
-      normalization: { kind: "identity" },
-      weight: grader.weight,
-      required: true,
-      hardGate: grader.hardGate,
-      privileged: grader.privileged,
-      fixtureRefs: []
-    }],
-    aggregation: "weighted_mean",
-    unscorable: "exclude_optional_require_all_required"
-  }, [closure.reward]);
-  const canonical = compileBoundGraders2(binding, [closure.reward])[0];
-  const implementation = (spec) => {
-    const { rewardEligible: _eligible, taskIds: _taskIds, ...rest } = spec;
-    return rest.kind === "model_judge" ? { ...rest, temperature: rest.temperature ?? 0 } : rest;
-  };
-  if (contentHash(implementation(grader)) !== contentHash(implementation(canonical))) fail("calibration_grader_changed");
-  if (grader.kind === "model_judge") assertJudgeFixtureMembership(value, grader, projection, closure);
-  return {
-    kind: "independent_reward_calibration",
-    fixtureId: id,
-    task: TaskRecordSchema.parse({
-      id,
-      clusterKey: id,
-      split: "validation",
-      input: fixture.input,
-      expectedOutput: fixture.expectedOutput,
-      privilegedContextRef: null
-    }),
-    evaluatorContext: fixture.evaluatorContext,
-    evidence: {
-      output: fixture.output,
-      artifactRefs: fixture.artifactRefs,
-      runtimeEventRefs: fixture.runtimeEventRefs,
-      infrastructureError: fixture.infrastructureError
-    },
-    grader: canonical,
-    reward: closure.reward,
-    binding,
-    expected,
-    source: {
-      reward: projection.sourceReward,
-      fixtureSet: projection.fixtureSet,
-      check: projection.calibrationCheck,
-      closure: projection.closureRef,
-      fixtureHash: projection.fixtureHash,
-      checkResultHash: projection.checkResultHash
-    }
-  };
-}
-function readPrivateClosure(value, reference) {
-  if (reference.visibility !== "host_private" || reference.sizeBytes > MAX_REWARD_CALIBRATION_CLOSURE_BYTES || reference.mediaType !== "application/vnd.openpond.reward-calibration-closure+json") fail("calibration_closure_not_private");
-  const files = value.files.filter((file) => file.asset.id === reference.id);
-  if (files.length !== 1 || contentHash(files[0].asset) !== contentHash(reference)) fail("calibration_closure_asset_changed");
-  const bytes = decodeTasksetPackageFile(files[0]);
-  const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-  const closure = verifyRewardCalibrationClosure(JSON.parse(text));
-  if (contentHash(rewardCalibrationClosureAsset(closure).asset) !== contentHash(reference)) fail("calibration_closure_reference_changed");
-  const aliases = value.files.filter((file) => file.asset.contentHash === reference.contentHash || file.asset.id === reference.id || file.asset.path === reference.path);
-  if (aliases.some((file) => file.asset.visibility !== "host_private")) fail("calibration_closure_visible_alias");
-  const isAlias = (ref) => ref.id === reference.id || ref.path === reference.path || ref.contentHash === reference.contentHash;
-  for (const task of value.taskset.tasks) {
-    if (task.artifactRefs.some(isAlias) || (task.requiredOutputs ?? []).some((output) => output.schemaRef && isAlias(output.schemaRef)) || task.privilegedContextRef && value.files.some((file) => file.asset.id === task.privilegedContextRef && isAlias(file.asset)))
-      fail("calibration_closure_task_alias");
-    if (containsClosure(task.input, text, reference.contentHash) || containsClosure(task.policyVisibleContext, text, reference.contentHash))
-      fail("calibration_closure_inline_alias");
-  }
-  for (const ref of [value.environment.actionSchemaRef, value.environment.observationSchemaRef, value.environment.stateSchemaRef])
-    if (ref && isAlias(ref)) fail("calibration_closure_environment_schema_alias");
-  for (const metadata of [value.taskset.metadata.environmentResources, value.environment.metadata.resources]) {
-    if (metadata === void 0) continue;
-    const resources = z11.array(z11.object({ id: z11.string().optional(), path: z11.string(), visibility: z11.string().optional() }).passthrough()).parse(metadata);
-    for (const resource of resources) {
-      const file = value.files.find((item) => item.asset.path === resource.path);
-      if (resource.id === reference.id || resource.path === reference.path || file && isAlias(file.asset))
-        fail("calibration_closure_environment_resource_alias");
-    }
-  }
-  return closure;
-}
-function containsClosure(value, text, hash) {
-  if (typeof value === "string") return value === text || sha256(value) === hash;
-  if (!value || typeof value !== "object") return false;
-  if (sha256(JSON.stringify(value)) === hash) return true;
-  return Object.values(value).some((item) => containsClosure(item, text, hash));
-}
-function fail(code) {
-  throw new Error(code);
-}
-function assertJudgeFixtureMembership(value, grader, selected, closure) {
-  const graderId = grader.id;
-  const authoring = value.taskset.metadata.ordinaryAuthoring ?? value.taskset.metadata.starterAuthoring;
-  const mapping = z11.object({ judgeCalibrationFixtures: z11.record(z11.string(), z11.array(z11.string().min(1)).max(500)) }).passthrough().parse(authoring);
-  const expected = closure.check.fixtureRefs.map((ref) => `calibration-${contentHash([selected.sourceReward, ref.id])}`);
-  if (contentHash(mapping.judgeCalibrationFixtures[graderId] ?? []) !== contentHash(expected)) fail("calibration_judge_membership_changed");
-  const fixtures = authoredFixtures(value);
-  for (let index = 0; index < expected.length; index++) {
-    const matches = fixtures.filter((fixture) => fixture.id === expected[index]);
-    if (matches.length !== 1) fail("calibration_judge_membership_changed");
-    const authored = matches[0];
-    const projected = ProjectionSchema.parse(authored.metadata.rewardCalibration);
-    const expectation = projected.fixture.expected;
-    if (expectation.status !== "scored" || typeof expectation.passed !== "boolean" || authored.expectedPassed !== expectation.passed || authored.expectedRewardEligible !== grader.rewardEligible || authored.label !== (expectation.passed ? "positive" : "negative") || contentHash(authored.output) !== contentHash(projected.fixture.output) || authored.infrastructureError !== projected.fixture.infrastructureError) fail("calibration_judge_membership_changed");
-    const retained = closure.check.fixtureRefs[index];
-    const result = closure.check.results.find((item) => item.fixture.id === retained.id);
-    if (authored.taskId !== authored.id || projected.fixture.id !== retained.id || projected.fixtureHash !== retained.contentHash || contentHash(projected.fixture) !== retained.contentHash || projected.checkResultHash !== contentHash(result) || contentHash(projected.sourceReward) !== contentHash(selected.sourceReward) || contentHash(projected.fixtureSet) !== contentHash(selected.fixtureSet) || contentHash(projected.calibrationCheck) !== contentHash(selected.calibrationCheck) || contentHash(projected.closureRef) !== contentHash(selected.closureRef) || (projected.graderId ?? projected.sourceReward.id) !== graderId) fail("calibration_judge_membership_changed");
-  }
-}
-
-// src/taskset-package-contracts.ts
-import { z as z12 } from "zod";
-import { EnvironmentReleaseSchema as EnvironmentReleaseSchema3, VerifierSetReleaseSchema as VerifierSetReleaseSchema3, verifyEnvironmentRelease as verifyEnvironmentRelease3, verifyVerifierSetRelease as verifyVerifierSetRelease3 } from "@openpond/evals";
-import { assertTasksetRelease as assertTasksetRelease2, TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
-import { assertBoundedTaskJson as assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
-import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
-
-// src/model-taskset-authoring-lineage.ts
-import { sameLearningRef as sameLearningRef3 } from "@openpond/evals/learning";
-function modelAuthoredTasksetId(lineage) {
-  return `model-authored-taskset-${contentHash({ owner: lineage.owner, root: lineage.root })}`;
-}
-function assertModelTasksetAuthoring(taskset) {
-  if (taskset.metadata.modelTasksetAuthoring === void 0) return null;
-  const lineage = ModelTasksetAuthoringSchema.parse(taskset.metadata.modelTasksetAuthoring);
-  if (taskset.id !== modelAuthoredTasksetId(lineage) || (taskset.revision === 1 ? !sameLearningRef3(lineage.parent, lineage.root) : lineage.parent.id !== taskset.id || lineage.parent.revision !== taskset.revision - 1)) {
-    throw new Error("Authored Taskset revision differs from its ownership lineage.");
-  }
-  return lineage;
-}
-
-// src/taskset-package-contracts.ts
-var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z12.object({
-  schemaVersion: z12.literal("openpond.tasksetPackage.v1"),
-  taskset: TasksetReleaseSchema2,
-  environment: EnvironmentReleaseSchema3,
-  verifierSet: VerifierSetReleaseSchema3,
-  files: z12.array(TasksetPackageFileSchema).max(1e4),
-  modelResources: BoundModelResourcesSchema.optional(),
-  learningResources: TasksetPackageLearningResourcesSchema.optional()
-}).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z12.string().regex(/^[a-f0-9]{64}$/) }).strict();
-function tasksetPackageRewardBinding(value) {
-  return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
-}
-function resolveTasksetPackageInstructions(value) {
-  if (value.learningResources) return taskBatchPackageMetadata2(value.taskset).definition.instructions;
-  if (value.modelResources) return value.modelResources.taskDefinition.instructions;
-  const authoring = z12.object({ instructions: z12.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
-  return authoring.instructions ?? "";
-}
-function validateTasksetPackage(value) {
-  assertBoundedTaskJson2(value, MAX_TASKSET_PACKAGE_BYTES);
-  const result = TasksetPackageSchema.parse(value);
-  const { contentHash: hash, ...content } = result;
-  if (contentHash(content) !== hash) throw new Error("Taskset package content hash differs from its bytes.");
-  const { taskset, environment, verifierSet } = result;
-  assertTasksetRelease2(taskset);
-  const authoring = assertModelTasksetAuthoring(taskset);
-  if (authoring && (result.modelResources || result.learningResources)) throw new Error("Taskset package cannot declare competing authoring graphs.");
-  if (!verifyEnvironmentRelease3(environment) || !verifyVerifierSetRelease3(verifierSet) || !same2(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same2(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same2(taskset.environment, environment.contract) || !same2(taskset.graders, verifierSet.graders)) {
-    throw new Error("Taskset package execution releases do not match its Taskset.");
-  }
-  const files = /* @__PURE__ */ new Map();
-  for (const file of result.files) {
-    if (files.has(file.asset.id)) throw new Error(`Duplicate Taskset asset identity: ${file.asset.id}.`);
-    decodeTasksetPackageFile(file);
-    files.set(file.asset.id, file);
-  }
-  function requireAsset(ref) {
-    const file = files.get(ref.id);
-    if (!file || !same2(file.asset, ref)) throw new Error(`Taskset package asset is missing or mismatched: ${ref.id}.`);
-  }
-  for (const task of taskset.tasks) {
-    for (const asset of task.artifactRefs) requireAsset(asset);
-    for (const output of task.requiredOutputs ?? []) if (output.schemaRef) requireAsset(output.schemaRef);
-    if (task.privilegedContextRef && files.get(task.privilegedContextRef)?.asset.visibility !== "host_private") {
-      throw new Error(`Taskset package private context is missing: ${task.id}.`);
-    }
-  }
-  for (const ref of [environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) if (ref) requireAsset(ref);
-  for (const grader of taskset.graders) {
-    const ref = "verifierRef" in grader ? grader.verifierRef : "rubricRef" in grader ? grader.rubricRef : null;
-    if (ref) {
-      requireAsset(ref);
-      if (ref.visibility === "policy") throw new Error(`Taskset grader asset must be private: ${ref.id}.`);
-    }
-  }
-  if (taskset.metrics?.customAggregator) {
-    const aggregator = taskset.metrics.customAggregator;
-    const modules = result.files.filter((file) => file.asset.path === aggregator.module);
-    if (modules.length !== 1 || modules[0].asset.contentHash !== aggregator.contentHash || modules[0].asset.sizeBytes > 524288 || modules[0].asset.visibility === "policy") {
-      throw new Error("Taskset metric module is missing or mismatched, public, or exceeds the source limit.");
-    }
-  }
-  for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
-    if (declarations === void 0) continue;
-    for (const resource of z12.array(z12.object({ path: z12.string().min(1) }).passthrough()).parse(declarations)) {
-      if (!result.files.some((file) => file.asset.path === resource.path)) throw new Error(`Taskset environment resource is missing: ${resource.path}.`);
-    }
-  }
-  if (result.learningResources) {
-    if (result.modelResources) throw new Error("Taskset package cannot declare competing authoring graphs.");
-    const learning = validateTasksetLearningResources(taskset, result.learningResources);
-    for (const expected of learningPackageContextFiles(learning)) {
-      if (!same2(files.get(expected.asset.id), expected)) throw new Error("Taskset private context differs from its reviewed evidence.");
-    }
-    for (const asset of learning.assets) requireAsset(asset.asset);
-  } else if (result.modelResources) {
-    const model = validateModelTasksetPackage({ ...result.modelResources, taskset, executionResources: { environment, verifierSet } });
-    for (const asset of model.assets) requireAsset(asset.asset);
-  } else if (["starter", "rewardBinding", "rewardExecution", "modelTasksetDerivation", "learning"].some((key) => taskset.metadata[key] !== void 0)) {
-    throw new Error("Bound Taskset publication requires its complete model resources.");
-  }
-  resolveTasksetPackageExecution(result);
-  resolveTasksetPackageInstructions(result);
-  assertTasksetCalibrationClosures(result);
-  return result;
-}
-function createTasksetPackage(value) {
-  assertBoundedTaskJson2(value, MAX_TASKSET_PACKAGE_BYTES);
-  const content = TasksetPackageContentSchema.parse(value);
-  return validateTasksetPackage({ ...content, contentHash: contentHash(content) });
-}
-function same2(left, right) {
-  return contentHash({ value: left }) === contentHash({ value: right });
-}
-
-export {
-  ConnectedDatasetSourceRefSchema,
-  DatasetSplitSchema,
-  DatasetSemanticFieldSchema,
-  DatasetSemanticSchemaSchema,
-  DatasetShardRefSchema,
-  DatasetArtifactManifestSchema,
-  DatasetArtifactSummarySchema,
-  DatasetCatalogItemSchema,
-  DatasetCatalogResponseSchema,
-  DatasetArtifactRegistryEntrySchema,
-  DatasetRowPageRequestSchema,
-  DatasetRowPageSchema,
-  DatasetStorageSettingsSchema,
-  DatasetStorageRootSchema,
-  DatasetStorageStateSchema,
-  UpdateDatasetStorageSettingsRequestSchema,
-  DatasetSourceReviewStatusSchema,
-  HuggingFaceDatasetSourceRefSchema,
-  UploadedFileDatasetSourceRefSchema,
-  GeneratedDatasetSourceRefSchema,
-  LearningBatchDatasetSourceRefSchema,
-  ExternalDatasetSourceRefSchema,
-  HarnessActionBindingSchema,
-  TasksetSplitSchema,
-  TasksetPurposeSchema,
-  TasksetBenchmarkBindingSchema,
-  TasksetPreferenceComparisonBindingSchema,
-  TrainingSourceConsentSchema,
-  TrainingSourceRefSchema,
-  TasksetSourceRefSchema,
-  TaskPolicyBoundarySchema,
-  TaskAssetRefSchema,
-  TaskRequiredOutputSchema,
-  TaskDataRecordSchema,
-  TasksetEnvironmentResourceSchema,
-  DemonstrationSignalSchema,
-  PreferenceSignalSchema,
-  CorrectionSignalSchema,
-  FeedbackSignalSchema,
-  RewardSignalSchema,
-  LabelSignalSchema,
-  LearningSignalRefSchema,
-  LearningSignalInventorySchema,
-  TasksetEnvironmentContractSchema,
-  TasksetCapabilityManifestSchema,
-  DeterministicGraderSpecSchema,
-  RubricGraderSpecSchema,
-  HumanGraderSpecSchema,
-  CustomVerifierGraderSpecSchema,
-  GraderSpecSchema,
-  GraderFixtureLabelSchema,
-  GraderFixtureSchema,
-  modelAuthoredTasksetId,
-  assertModelTasksetAuthoring,
-  ModelStarterEnvironmentAttemptSchema,
-  verifyModelStarterEnvironmentAttempt,
-  ModelStarterExecutionSchema,
-  ModelStarterToolFixtureScriptSchema,
-  modelStarterExecutionAssetId,
-  createModelStarterExecutionAsset,
-  resolveModelStarterExecutionAsset,
-  validateModelStarterExecution,
-  NativeHarnessExperimentAttemptSchema,
-  verifyNativeHarnessExperimentAttempt,
-  ModelTasksetExecutionResourcesSchema,
-  modelTasksetExecutionResourcesAssetId,
-  createModelTasksetExecutionResourcesAsset,
-  resolveModelTasksetExecutionResourcesAsset,
-  ModelTasksetDerivationSchema,
-  ModelTasksetPackageSchema,
-  deriveModelTaskset,
-  compileModelTasksetReward,
-  validateModelTasksetPackage,
-  TasksetPackageLearningResourcesSchema,
-  learningPackageContextFiles,
-  validateTasksetLearningResources,
-  MAX_TASKSET_PACKAGE_BYTES,
-  TasksetPackageFileSchema,
-  decodeTasksetPackageFile,
-  resolveTasksetPackageExecution,
-  createTasksetPackageExecutionFile,
-  assertTasksetCalibrationClosures,
-  resolveTasksetCalibrationFixture,
-  TasksetPackageContentSchema,
-  TasksetPackageSchema,
-  tasksetPackageRewardBinding,
-  resolveTasksetPackageInstructions,
-  validateTasksetPackage,
-  createTasksetPackage
-};
-//# sourceMappingURL=chunk-FHCSDXIA.js.map