openpond-sdk 0.5.6 → 0.5.7

package/dist/chunk-QFT2MCIC.js

@@ -0,0 +1,1526 @@
+import {
+  ModelStarterExecutionSchema,
+  ModelTasksetPackageSchema,
+  createModelStarterExecutionAsset,
+  modelStarterExecutionAssetId,
+  validateModelStarterExecution,
+  validateModelTasksetPackage
+} from "./chunk-4IDTRFW2.js";
+import {
+  ModelTasksetAuthoringSchema
+} from "./chunk-S7I45WJQ.js";
+import {
+  ChatModelRefSchema
+} from "./chunk-UKVK7MRJ.js";
+import {
+  ImmutableAssetRefSchema,
+  ImmutableReleaseRefSchema,
+  ReleaseHashSchema,
+  ReleaseIdSchema,
+  VersionedReleaseRefSchema,
+  contentHash,
+  sha256
+} from "./chunk-QUOW6URQ.js";
+import {
+  canonicalJson
+} from "./chunk-ZNFOVV7B.js";
+
+// src/taskset-draft-dataset-artifacts.ts
+import { z } from "zod";
+var IdSchema = z.string().trim().min(1).max(240);
+var TimestampSchema = z.string().trim().min(1);
+var HashSchema = z.string().trim().min(8).max(256);
+var RelativePathSchema = z.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 = z.enum([
+  "train",
+  "validation",
+  "test",
+  "frozen_eval"
+]);
+var DatasetSemanticFieldSchema = z.object({
+  name: z.string().trim().min(1).max(500),
+  semanticRole: z.enum([
+    "row_id",
+    "cluster_id",
+    "prompt",
+    "messages",
+    "demonstration",
+    "chosen",
+    "rejected",
+    "expected_output",
+    "privileged_context",
+    "reward",
+    "feedback",
+    "tag",
+    "metadata"
+  ]),
+  logicalType: z.enum([
+    "string",
+    "integer",
+    "float",
+    "boolean",
+    "json",
+    "messages"
+  ]),
+  nullable: z.boolean(),
+  policy: z.enum(["visible", "privileged", "metadata"])
+});
+var DatasetSemanticSchemaSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetSemanticSchema.v1"),
+  fields: z.array(DatasetSemanticFieldSchema).min(1).max(1e4),
+  schemaHash: HashSchema
+});
+var DatasetShardRefSchema = z.object({
+  id: IdSchema,
+  split: DatasetSplitSchema,
+  path: RelativePathSchema,
+  contentHash: HashSchema,
+  schemaHash: HashSchema,
+  sizeBytes: z.number().int().nonnegative(),
+  rowCount: z.number().int().positive(),
+  rowGroupCount: z.number().int().positive()
+});
+var DatasetArtifactManifestSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetArtifact.v1"),
+  id: IdSchema,
+  tasksetId: IdSchema,
+  tasksetRevision: z.number().int().positive(),
+  contentHash: HashSchema,
+  format: z.literal("parquet"),
+  schema: DatasetSemanticSchemaSchema,
+  shards: z.array(DatasetShardRefSchema).min(1).max(1e5),
+  rowCount: z.number().int().positive(),
+  splitCounts: z.record(DatasetSplitSchema, z.number().int().nonnegative()),
+  sourceReceiptRefs: z.array(IdSchema).min(1).max(1e5),
+  mappingHash: HashSchema,
+  qualityReportHash: HashSchema,
+  createdAt: TimestampSchema
+});
+var DatasetArtifactSummarySchema = z.object({
+  schemaVersion: z.literal("openpond.datasetArtifactSummary.v1"),
+  artifactId: IdSchema,
+  tasksetId: IdSchema,
+  tasksetRevision: z.number().int().positive(),
+  format: z.literal("parquet"),
+  rowCount: z.number().int().positive(),
+  splitCounts: z.record(DatasetSplitSchema, z.number().int().nonnegative()),
+  sizeBytes: z.number().int().nonnegative(),
+  contentHash: HashSchema,
+  available: z.boolean(),
+  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
+  createdAt: TimestampSchema
+});
+var DatasetCatalogItemSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetCatalogItem.v1"),
+  tasksetId: IdSchema,
+  tasksetRevision: z.number().int().positive(),
+  artifactId: IdSchema.nullable(),
+  name: z.string().trim().min(1).max(500),
+  status: z.enum([
+    "draft",
+    "awaiting_disclosure_approval",
+    "awaiting_materialization_approval",
+    "materializing",
+    "validating",
+    "needs_review",
+    "baselining",
+    "ready",
+    "blocked",
+    "failed",
+    "archived"
+  ]),
+  storageKind: z.enum(["inline", "parquet"]),
+  rowCount: z.number().int().nonnegative(),
+  splitCounts: z.record(DatasetSplitSchema, z.number().int().nonnegative()),
+  sizeBytes: z.number().int().nonnegative().nullable(),
+  available: z.boolean(),
+  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema
+});
+var DatasetCatalogResponseSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetCatalog.v1"),
+  profileId: IdSchema,
+  datasets: z.array(DatasetCatalogItemSchema),
+  generatedAt: TimestampSchema
+});
+var DatasetArtifactRegistryEntrySchema = z.object({
+  schemaVersion: z.literal("openpond.datasetArtifactRegistry.v1"),
+  manifest: DatasetArtifactManifestSchema,
+  profileId: IdSchema,
+  storageRoot: z.string().trim().min(1).max(4e3),
+  relativeManifestPath: RelativePathSchema,
+  available: z.boolean(),
+  unavailableReason: z.string().trim().min(1).max(2e3).nullable(),
+  verifiedAt: TimestampSchema.nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema
+});
+var DatasetRowPageRequestSchema = z.object({
+  split: DatasetSplitSchema.nullable().default(null),
+  cursor: z.string().trim().min(1).max(2e3).nullable().default(null),
+  limit: z.number().int().min(1).max(100).default(25),
+  columns: z.array(z.string().trim().min(1).max(500)).max(100).default([])
+});
+var DatasetRowPageSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetRowPage.v1"),
+  tasksetId: IdSchema,
+  tasksetRevision: z.number().int().positive(),
+  artifactHash: HashSchema,
+  split: DatasetSplitSchema.nullable(),
+  rows: z.array(z.record(z.string(), z.unknown())).max(100),
+  nextCursor: z.string().max(2e3).nullable(),
+  totalRows: z.number().int().nonnegative(),
+  returnedRows: z.number().int().nonnegative()
+});
+var DatasetStorageSettingsSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetStorageSettings.v1"),
+  datasetStorePath: z.string().trim().min(1).max(4e3),
+  updatedAt: TimestampSchema
+});
+var DatasetStorageRootSchema = z.object({
+  id: IdSchema,
+  label: z.string().trim().min(1).max(500),
+  path: z.string().trim().min(1).max(4e3),
+  datasetStorePath: z.string().trim().min(1).max(4e3),
+  kind: z.enum(["local", "network", "removable", "cache"]),
+  configured: z.boolean(),
+  mounted: z.boolean(),
+  writable: z.boolean(),
+  totalBytes: z.number().int().nonnegative().nullable(),
+  freeBytes: z.number().int().nonnegative().nullable()
+});
+var DatasetStorageStateSchema = z.object({
+  schemaVersion: z.literal("openpond.datasetStorageState.v1"),
+  settings: DatasetStorageSettingsSchema,
+  storageRoots: z.array(DatasetStorageRootSchema)
+});
+var UpdateDatasetStorageSettingsRequestSchema = z.object({
+  datasetStorePath: z.string().trim().min(1).max(4e3)
+});
+
+// src/taskset-draft-dataset-sources.ts
+import { z as z2 } from "zod";
+var IdSchema2 = z2.string().trim().min(1).max(240);
+var TimestampSchema2 = z2.string().trim().min(1);
+var HashSchema2 = z2.string().trim().min(8).max(256);
+var MetadataSchema = z2.record(z2.string(), z2.unknown()).default({});
+var RevisionSchema = z2.string().trim().min(7).max(256);
+var DatasetSourceReviewStatusSchema = z2.enum([
+  "pending",
+  "approved",
+  "review",
+  "blocked"
+]);
+var ExternalDatasetSourceBaseSchema = z2.object({
+  id: IdSchema2,
+  profileId: IdSchema2,
+  title: z2.string().trim().min(1).max(500),
+  sourceHash: HashSchema2,
+  occurredAt: TimestampSchema2,
+  licensingStatus: DatasetSourceReviewStatusSchema,
+  secretScanStatus: z2.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z2.enum(["pending", "passed", "review", "blocked"]),
+  metadata: MetadataSchema
+});
+var HuggingFaceDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z2.literal("openpond.huggingFaceDatasetSource.v1"),
+  kind: z2.literal("huggingface"),
+  repositoryId: z2.string().trim().regex(/^[^/\s]+\/[^/\s]+$/).max(500),
+  repositoryUrl: z2.string().url().max(2e3),
+  revision: RevisionSchema,
+  configuration: z2.string().trim().min(1).max(500),
+  upstreamSplits: z2.array(z2.string().trim().min(1).max(500)).min(1).max(1e3),
+  gated: z2.boolean(),
+  private: z2.boolean(),
+  declaredLicense: z2.string().trim().min(1).max(500).nullable(),
+  sourceFileHashes: z2.array(HashSchema2).min(1).max(1e5)
+});
+var UploadedFileDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z2.literal("openpond.uploadedFileDatasetSource.v1"),
+  kind: z2.literal("uploaded_file"),
+  originalFileNames: z2.array(z2.string().trim().min(1).max(500)).min(1).max(1e3),
+  mediaTypes: z2.array(z2.string().trim().min(1).max(200)).min(1).max(1e3),
+  sourceFileHashes: z2.array(HashSchema2).min(1).max(1e3),
+  totalBytes: z2.number().int().nonnegative(),
+  parserVersion: z2.string().trim().min(1).max(200)
+});
+var GeneratedDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z2.literal("openpond.generatedDatasetSource.v1"),
+  kind: z2.literal("generated"),
+  generatorId: IdSchema2,
+  generatorVersion: z2.string().trim().min(1).max(200),
+  seed: z2.number().int(),
+  generatorHash: HashSchema2
+});
+var LearningBatchDatasetSourceRefSchema = ExternalDatasetSourceBaseSchema.extend({
+  schemaVersion: z2.literal("openpond.learningBatchDatasetSource.v1"),
+  kind: z2.literal("learning_batch"),
+  batch: z2.object({ id: IdSchema2, revision: z2.number().int().positive(), contentHash: HashSchema2 }).strict(),
+  taskDefinition: z2.object({ id: IdSchema2, revision: z2.number().int().positive(), contentHash: HashSchema2 }).strict(),
+  admittedBy: IdSchema2
+});
+var ExternalDatasetSourceRefSchema = z2.discriminatedUnion("kind", [
+  HuggingFaceDatasetSourceRefSchema,
+  UploadedFileDatasetSourceRefSchema,
+  GeneratedDatasetSourceRefSchema,
+  LearningBatchDatasetSourceRefSchema
+]);
+
+// src/taskset-draft-harness-actions.ts
+import { z as z3 } from "zod";
+var HarnessActionBindingSchema = z3.object({
+  schemaVersion: z3.literal("openpond.harnessActionBinding.v1"),
+  actionId: ReleaseIdSchema,
+  modelToolName: z3.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+  description: z3.string().trim().min(1).max(1e3),
+  inputSchema: z3.record(z3.string(), z3.unknown()),
+  actionSchemaHash: ReleaseHashSchema,
+  agentRelease: ImmutableReleaseRefSchema,
+  implementationHash: ReleaseHashSchema,
+  runtimeBindingId: ReleaseIdSchema,
+  capabilityReceiptHash: ReleaseHashSchema,
+  sideEffect: z3.enum(["read", "write"]),
+  studentVisible: z3.boolean(),
+  timeoutMs: z3.number().int().positive().max(36e5),
+  episodeArgumentBindings: z3.array(
+    z3.object({
+      argument: ReleaseIdSchema,
+      source: z3.literal("case_id")
+    }).strict()
+  ).max(20).default([])
+}).strict();
+
+// src/taskset-draft-core.ts
+import { z as z4 } from "zod";
+var IdSchema3 = z4.string().trim().min(1).max(240);
+var TimestampSchema3 = z4.string().trim().min(1);
+var HashSchema3 = z4.string().trim().min(8).max(256);
+var Sha256Schema = z4.string().trim().regex(/^[a-f0-9]{64}$/);
+var CodeIdentifierSchema = z4.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+var MetadataSchema2 = z4.record(z4.string(), z4.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 = z4.enum(["general", "benchmark"]);
+var TasksetBenchmarkBindingSchema = z4.object({
+  schemaVersion: z4.literal("openpond.tasksetBenchmark.v1"),
+  definitionId: IdSchema3,
+  releaseId: IdSchema3,
+  releaseHash: Sha256Schema,
+  managedReleasePath: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Benchmark release paths must remain relative."),
+  adaptationSplit: TasksetSplitSchema,
+  evaluationSplit: TasksetSplitSchema,
+  primaryMetric: z4.enum([
+    "foreground_tokens",
+    "success_rate",
+    "latency_ms",
+    "cost_usd"
+  ]),
+  qualityGate: z4.enum(["none", "non_regression", "all_pass"]),
+  source: z4.enum(["builtin", "imported"]),
+  metadata: MetadataSchema2
+});
+var TasksetPreferenceComparisonBindingSchema = z4.object({
+  schemaVersion: z4.literal("openpond.tasksetPreferenceComparisonBinding.v1"),
+  releaseId: IdSchema3,
+  releaseHash: Sha256Schema,
+  publishedAt: TimestampSchema3,
+  metadata: MetadataSchema2
+});
+var TrainingSourceConsentSchema = z4.object({
+  status: z4.enum(["pending", "granted", "denied", "revoked"]),
+  scope: z4.enum(["metadata_only", "selected_turns", "full_session"]),
+  grantedBy: NullableIdSchema,
+  grantedAt: TimestampSchema3.nullable(),
+  purpose: z4.literal("task_authoring_and_evaluation")
+});
+var TrainingSourceRefSchema = z4.object({
+  schemaVersion: z4.literal("openpond.trainingSource.v1"),
+  id: IdSchema3,
+  profileId: IdSchema3,
+  sessionId: IdSchema3,
+  turnIds: z4.array(IdSchema3).max(1e3).default([]),
+  workspaceId: NullableIdSchema,
+  sourceHash: HashSchema3,
+  clusterKey: IdSchema3,
+  title: z4.string().trim().min(1).max(500),
+  occurredAt: TimestampSchema3,
+  consent: TrainingSourceConsentSchema,
+  connectedAppIds: z4.array(IdSchema3).max(100).default([]),
+  secretScanStatus: z4.enum(["pending", "passed", "blocked"]),
+  piiScanStatus: z4.enum(["pending", "passed", "review", "blocked"]),
+  licensingStatus: z4.enum(["pending", "approved", "review", "blocked"]),
+  metadata: MetadataSchema2
+});
+var TasksetSourceRefSchema = z4.union([
+  TrainingSourceRefSchema,
+  ExternalDatasetSourceRefSchema
+]);
+var TaskPolicyBoundarySchema = z4.object({
+  policyVisibleFields: z4.array(IdSchema3).max(1e3).default([]),
+  privilegedFields: z4.array(IdSchema3).max(1e3).default([]),
+  hiddenGraderRefs: z4.array(IdSchema3).max(100).default([]),
+  connectedAppScopes: z4.array(IdSchema3).max(100).default([])
+});
+var TaskAssetRefSchema = z4.object({
+  id: IdSchema3,
+  sourceRefId: IdSchema3,
+  artifactRef: z4.string().trim().min(1).max(4e3).refine(safeRelativeFilePath, "Task asset references must be safe relative paths."),
+  fileName: z4.string().trim().min(1).max(500).refine(safeFileName, "Task asset file names must not contain path separators."),
+  mediaType: z4.string().trim().min(1).max(200),
+  sha256: Sha256Schema,
+  sizeBytes: z4.number().int().nonnegative().max(25e7),
+  split: TasksetSplitSchema,
+  metadata: MetadataSchema2
+});
+var TaskRequiredOutputSchema = z4.object({
+  path: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Required output paths must stay inside the Work output directory."),
+  mediaType: z4.string().trim().min(1).max(200),
+  schemaRef: IdSchema3.nullable().optional(),
+  maxBytes: z4.number().int().positive().max(1e7).optional(),
+  metadata: MetadataSchema2
+});
+var TaskDataRecordSchema = z4.object({
+  schemaVersion: z4.literal("openpond.taskData.v1"),
+  id: IdSchema3,
+  clusterKey: IdSchema3,
+  split: TasksetSplitSchema,
+  input: z4.record(z4.string(), z4.unknown()),
+  expectedOutput: z4.record(z4.string(), z4.unknown()).nullable(),
+  policyVisibleContext: z4.record(z4.string(), z4.unknown()).default({}),
+  privilegedContextRef: NullableIdSchema,
+  sourceRefs: z4.array(IdSchema3).min(1).max(100),
+  assets: z4.array(TaskAssetRefSchema).max(1e3).optional(),
+  resourceRefs: z4.array(IdSchema3).max(1e3).optional(),
+  requiredOutputs: z4.array(TaskRequiredOutputSchema).max(100).optional(),
+  tags: z4.array(IdSchema3).max(100).default([]),
+  metadata: MetadataSchema2
+});
+var TasksetEnvironmentResourceSchema = z4.object({
+  id: IdSchema3,
+  kind: z4.enum(["file", "catalog", "configuration", "code_module"]),
+  path: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Environment resource paths must remain relative."),
+  mediaType: z4.string().trim().min(1).max(200).nullable().optional(),
+  visibility: z4.enum(["policy_visible", "policy_hidden", "privileged"]),
+  required: z4.boolean(),
+  metadata: MetadataSchema2
+});
+var LearningSignalBaseSchema = z4.object({
+  id: IdSchema3,
+  taskId: NullableIdSchema,
+  sourceRefs: z4.array(IdSchema3).min(1).max(100),
+  artifactRef: IdSchema3,
+  approved: z4.boolean(),
+  confidence: z4.number().min(0).max(1),
+  metadata: MetadataSchema2
+});
+var DemonstrationSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z4.literal("demonstration"),
+  prompt: z4.string().max(1e5).nullable().default(null),
+  response: z4.string().max(2e5).nullable().default(null)
+});
+var PreferenceSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z4.literal("preference"),
+  prompt: z4.string().max(1e5),
+  chosen: z4.string().max(2e5),
+  rejected: z4.string().max(2e5),
+  rationale: z4.string().max(1e5).nullable().default(null)
+});
+var CorrectionSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z4.literal("correction"),
+  original: z4.string().max(2e5),
+  corrected: z4.string().max(2e5),
+  rationale: z4.string().max(1e5).nullable().default(null)
+});
+var FeedbackSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z4.literal("feedback"),
+  feedback: z4.string().max(1e5),
+  polarity: z4.enum(["positive", "negative", "mixed", "neutral"])
+});
+var RewardSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z4.literal("reward"),
+  task: z4.string().max(1e5),
+  rules: z4.array(z4.object({
+    id: IdSchema3,
+    points: z4.number().finite(),
+    condition: z4.string().trim().min(1).max(1e5)
+  })).min(1).max(1e3),
+  otherwisePoints: z4.number().finite(),
+  executable: z4.boolean()
+});
+var LabelSignalSchema = LearningSignalBaseSchema.extend({
+  kind: z4.literal("label"),
+  labelKind: z4.literal("rubric"),
+  task: z4.string().max(1e5),
+  criteria: z4.array(z4.object({
+    id: IdSchema3,
+    label: z4.string().trim().min(1).max(500),
+    description: z4.string().trim().min(1).max(1e5)
+  })).min(1).max(1e3),
+  calibrationExamples: z4.object({
+    positive: z4.string().trim().min(1).max(2e5),
+    negative: z4.string().trim().min(1).max(2e5),
+    boundary: z4.string().trim().min(1).max(2e5)
+  })
+});
+var LearningSignalRefSchema = z4.discriminatedUnion("kind", [
+  DemonstrationSignalSchema,
+  PreferenceSignalSchema,
+  CorrectionSignalSchema,
+  FeedbackSignalSchema,
+  RewardSignalSchema,
+  LabelSignalSchema
+]);
+var LearningSignalInventorySchema = z4.object({
+  demonstrations: z4.array(DemonstrationSignalSchema).max(1e5).default([]),
+  preferences: z4.array(PreferenceSignalSchema).max(1e5).default([]),
+  corrections: z4.array(CorrectionSignalSchema).max(1e5).default([]),
+  feedback: z4.array(FeedbackSignalSchema).max(1e5).default([]),
+  rewards: z4.array(RewardSignalSchema).max(1e5).default([]),
+  labels: z4.array(LabelSignalSchema).max(1e5).default([])
+});
+var TasksetEnvironmentContractSchema = z4.object({
+  protocolVersion: z4.literal("openpond.taskEnvironment.v1"),
+  kind: z4.enum(["chat", "agent", "program", "stateful_harness", "work"]),
+  entrypoint: z4.string().trim().min(1).max(1e3),
+  stateful: z4.boolean(),
+  deterministicSeeds: z4.boolean(),
+  toolNames: z4.array(IdSchema3).max(200).default([]),
+  actionBindings: z4.array(HarnessActionBindingSchema).max(200).optional(),
+  lifecycle: z4.array(z4.enum(["create", "reset", "step", "grade", "cleanup"])).min(1),
+  defaultTimeoutMs: z4.number().int().positive().max(36e5),
+  networkPolicy: z4.enum(["none", "declared_read_only", "declared_scoped"]),
+  resources: z4.array(TasksetEnvironmentResourceSchema).max(1e4).optional(),
+  metadata: MetadataSchema2
+});
+var TasksetCapabilityManifestSchema = z4.object({
+  schemaVersion: z4.literal("openpond.tasksetCapabilities.v1"),
+  taskKind: z4.enum(["chat", "single_agent", "multi_agent", "custom_program"]),
+  supportedSignals: z4.array(z4.enum(["demonstration", "preference", "correction", "feedback", "reward", "label"])),
+  compatibleMethods: z4.array(z4.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"])),
+  rewardKinds: z4.array(z4.enum(["none", "exact", "deterministic", "model_judge", "human"])),
+  requiresTools: z4.boolean(),
+  requiresState: z4.boolean(),
+  requiresPrivilegedGrading: z4.boolean(),
+  environmentPlacements: z4.array(z4.enum(["local", "remote", "colocated", "provider_native"])),
+  exportable: z4.boolean(),
+  portabilityBlockers: z4.array(z4.string().trim().min(1).max(2e3)).default([])
+});
+var GraderBaseSchema = z4.object({
+  id: IdSchema3,
+  version: z4.string().trim().min(1).max(100),
+  label: z4.string().trim().min(1).max(500),
+  weight: z4.number().min(0).max(1e3).default(1),
+  hardGate: z4.boolean().default(false),
+  rewardEligible: z4.boolean().default(false),
+  privileged: z4.boolean().default(false),
+  metadata: MetadataSchema2
+});
+var DeterministicGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z4.enum(["content", "schema", "file", "diff", "test", "runtime_event", "state"]),
+  config: z4.record(z4.string(), z4.unknown())
+});
+var RubricGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z4.literal("model_judge"),
+  rubric: z4.string().trim().min(1).max(5e4),
+  judge: ChatModelRefSchema,
+  calibrationFixtureRefs: z4.array(IdSchema3).min(1).max(500),
+  calibrationStatus: z4.enum(["pending", "passed", "failed"]),
+  temperature: z4.number().min(0).max(2).default(0)
+});
+var HumanGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z4.literal("human"),
+  rubric: z4.string().trim().min(1).max(5e4),
+  reviewerRole: z4.string().trim().min(1).max(500)
+});
+var CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
+  kind: z4.literal("custom_verifier"),
+  module: z4.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Custom verifier modules must use a safe relative path."),
+  exportName: CodeIdentifierSchema,
+  timeoutMs: z4.number().int().positive().max(3e5),
+  networkPolicy: z4.literal("none")
+});
+var GraderSpecSchema = z4.union([
+  DeterministicGraderSpecSchema,
+  RubricGraderSpecSchema,
+  HumanGraderSpecSchema,
+  CustomVerifierGraderSpecSchema
+]);
+var GraderFixtureLabelSchema = z4.enum([
+  "positive",
+  "negative",
+  "boundary",
+  "adversarial",
+  "prompt_injection",
+  "infrastructure_failure"
+]);
+var GraderFixtureSchema = z4.object({
+  id: IdSchema3,
+  taskId: IdSchema3,
+  label: GraderFixtureLabelSchema,
+  output: z4.record(z4.string(), z4.unknown()),
+  infrastructureError: z4.string().trim().min(1).max(1e4).nullable(),
+  expectedPassed: z4.boolean(),
+  expectedRewardEligible: z4.boolean(),
+  metadata: MetadataSchema2
+});
+
+// src/taskset-authored-contracts.ts
+import { z as z5 } from "zod";
+import { TasksetMetricPolicySchema } from "@openpond/evals/metrics";
+var IdSchema4 = z5.string().trim().min(1).max(240);
+var TimestampSchema4 = z5.string().trim().min(1);
+var HashSchema4 = z5.string().trim().min(8).max(256);
+var MetadataSchema3 = z5.record(z5.string(), z5.unknown()).default({});
+var NullableIdSchema2 = IdSchema4.nullable();
+var TASKSET_WORK_TOOL_NAMES = [
+  "work_capabilities",
+  "work_environment",
+  "work_list_files",
+  "work_read_file",
+  "work_read_document",
+  "work_write_file",
+  "work_write_docx",
+  "work_edit_file",
+  "work_delete_file",
+  "work_exec",
+  "work_save_output",
+  "work_stop"
+];
+var TasksetStatusSchema = z5.enum([
+  "draft",
+  "awaiting_disclosure_approval",
+  "awaiting_materialization_approval",
+  "materializing",
+  "validating",
+  "needs_review",
+  "baselining",
+  "ready",
+  "blocked",
+  "failed",
+  "archived"
+]);
+var DatasetBuildIntentSchema = z5.enum([
+  "demonstrations",
+  "preferences",
+  "verifiable_reward",
+  "rubric",
+  "discovery"
+]);
+var DatasetEvidenceTextSchema = z5.string().trim().max(1e5);
+var DatasetBuildSpecificationSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("demonstrations"),
+    behavior: DatasetEvidenceTextSchema,
+    examples: z5.array(z5.object({
+      id: IdSchema4,
+      prompt: DatasetEvidenceTextSchema,
+      response: DatasetEvidenceTextSchema
+    })).max(1e3).default([])
+  }),
+  z5.object({
+    kind: z5.literal("preferences"),
+    preference: DatasetEvidenceTextSchema,
+    pairs: z5.array(z5.object({
+      id: IdSchema4,
+      prompt: DatasetEvidenceTextSchema,
+      chosen: DatasetEvidenceTextSchema,
+      rejected: DatasetEvidenceTextSchema,
+      rationale: DatasetEvidenceTextSchema
+    })).max(1e3).default([])
+  }),
+  z5.object({
+    kind: z5.literal("verifiable_reward"),
+    task: DatasetEvidenceTextSchema,
+    rules: z5.array(z5.object({
+      id: IdSchema4,
+      points: z5.number().finite(),
+      condition: DatasetEvidenceTextSchema
+    })).max(1e3).default([]),
+    otherwisePoints: z5.number().finite().default(0)
+  }),
+  z5.object({
+    kind: z5.literal("rubric"),
+    task: DatasetEvidenceTextSchema,
+    criteria: z5.array(z5.object({
+      id: IdSchema4,
+      label: z5.string().trim().max(500),
+      description: DatasetEvidenceTextSchema
+    })).max(1e3).default([]),
+    positiveExample: DatasetEvidenceTextSchema,
+    negativeExample: DatasetEvidenceTextSchema,
+    boundaryExample: DatasetEvidenceTextSchema
+  })
+]);
+var GeneratedTaskFileSchema = z5.object({
+  path: z5.string().trim().min(1).max(1e3),
+  role: z5.enum(["environment", "verifier", "fixture"]),
+  content: z5.string().max(25e4)
+});
+var TrainingPathRecommendationSchema = z5.object({
+  primaryMethod: z5.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opsd", "sdpo"]),
+  bootstrap: z5.object({
+    method: z5.literal("sft"),
+    purpose: z5.literal("trajectory_bootstrap"),
+    demonstrationRefs: z5.array(IdSchema4).min(1).max(1e5),
+    limitations: z5.array(z5.string().trim().min(1).max(5e3)).min(1).max(100)
+  }).nullable()
+});
+var TrainingMethodReadinessReasonCodeSchema = z5.enum([
+  "taskset_not_ready",
+  "demonstrations_missing",
+  "preference_pairs_missing",
+  "preference_pairs_invalid",
+  "executable_reward_missing",
+  "reward_not_calibrated",
+  "reward_model_missing",
+  "value_model_required",
+  "frozen_eval_missing"
+]);
+var TrainingMethodReadinessSchema = z5.object({
+  method: z5.enum(["sft", "dpo", "grpo", "ppo"]),
+  status: z5.enum(["recommended", "compatible", "needs_dataset_work"]),
+  reasonCodes: z5.array(TrainingMethodReadinessReasonCodeSchema).default([]),
+  reasons: z5.array(z5.string().trim().min(1).max(5e3)).default([])
+});
+var TasksetReadinessFindingSchema = z5.object({
+  code: IdSchema4,
+  message: z5.string().trim().min(1).max(5e3),
+  path: z5.string().trim().max(2e3).nullable()
+});
+var TasksetReadinessReportSchema = z5.object({
+  schemaVersion: z5.literal("openpond.tasksetReadiness.v1"),
+  tasksetId: IdSchema4,
+  tasksetHash: HashSchema4,
+  ready: z5.boolean(),
+  recommendedMethod: z5.enum(["none", "retrieval", "sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
+  trainingPath: TrainingPathRecommendationSchema.nullable().default(null),
+  methodReadiness: z5.array(TrainingMethodReadinessSchema).default([]),
+  compatibleDestinationClasses: z5.array(
+    z5.enum(["export", "custom", "hosted_managed"])
+  ),
+  blockers: z5.array(TasksetReadinessFindingSchema).default([]),
+  advisories: z5.array(TasksetReadinessFindingSchema).default([]),
+  warnings: z5.array(z5.string().trim().min(1).max(5e3)).default([]),
+  generatedAt: TimestampSchema4
+});
+var AuthoringRepairSchema = z5.object({ attempt: z5.number().int().positive(), summary: z5.string().trim().min(1).max(5e3), createdAt: TimestampSchema4 });
+var AuthoringProvenanceSchema = z5.object({
+  schemaVersion: z5.literal("openpond.taskAuthoringProvenance.v1"),
+  model: ChatModelRefSchema.nullable(),
+  modelConfig: MetadataSchema3,
+  skillHash: HashSchema4,
+  promptTemplateVersion: z5.string().trim().min(1).max(200),
+  buildIntent: DatasetBuildIntentSchema.default("demonstrations"),
+  buildSpecification: DatasetBuildSpecificationSchema.nullable().default(null),
+  evidenceHashes: z5.array(HashSchema4).max(1e5),
+  tasksetSdkVersion: z5.string().trim().min(1).max(100),
+  sourceCommit: z5.string().trim().min(1).max(256).nullable(),
+  repairHistory: z5.array(AuthoringRepairSchema).max(1e3),
+  createdAt: TimestampSchema4
+});
+var TasksetSchema = z5.object({
+  schemaVersion: z5.literal("openpond.taskset.v1"),
+  id: IdSchema4,
+  revision: z5.number().int().positive().default(1),
+  profileId: IdSchema4,
+  profileRelease: VersionedReleaseRefSchema.nullable().optional(),
+  createImproveRunId: NullableIdSchema2.default(null),
+  name: z5.string().trim().min(1).max(500),
+  // Portable tasks may carry all instructions in their individual inputs.
+  // Preserve an absent package prompt; draft publication validates its objective.
+  objective: z5.string().trim().max(2e4),
+  purpose: TasksetPurposeSchema.default("general"),
+  benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
+  preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
+  status: TasksetStatusSchema,
+  sourceRefs: z5.array(TasksetSourceRefSchema).min(1).max(1e5),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  capabilities: TasksetCapabilityManifestSchema,
+  metrics: TasksetMetricPolicySchema.optional(),
+  tasks: z5.array(TaskDataRecordSchema).max(1e6),
+  graders: z5.array(GraderSpecSchema).min(1).max(1e3),
+  // Imported releases are inspectable before local calibration. Admission
+  // requires real fixtures separately in validateTaskset.
+  graderFixtures: z5.array(GraderFixtureSchema).max(1e5),
+  learningSignals: LearningSignalInventorySchema,
+  authoringProvenance: AuthoringProvenanceSchema,
+  readiness: TasksetReadinessReportSchema.nullable(),
+  contentHash: HashSchema4,
+  createdAt: TimestampSchema4,
+  updatedAt: TimestampSchema4,
+  metadata: MetadataSchema3
+}).superRefine((taskset, context) => {
+  if (taskset.purpose === "benchmark" && !taskset.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark Tasksets require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (taskset.purpose !== "benchmark" && taskset.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark Tasksets may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (taskset.datasetArtifact && taskset.tasks.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Artifact-backed Tasksets may not duplicate canonical rows inline.",
+      path: ["tasks"]
+    });
+  }
+  if (!taskset.datasetArtifact && taskset.tasks.length === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "A Taskset requires inline tasks or a Dataset artifact manifest.",
+      path: ["tasks"]
+    });
+  }
+});
+function isTrainingSourceRef(source) {
+  return source.schemaVersion === "openpond.trainingSource.v1";
+}
+
+// src/taskset-authored-validation.ts
+function validateTaskset(input) {
+  const parsed = TasksetSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      taskset: null,
+      computedHash: null,
+      issues: parsed.error.issues.map((issue) => ({
+        code: "schema_invalid",
+        severity: "error",
+        message: issue.message,
+        path: issue.path.join(".")
+      }))
+    };
+  }
+  const taskset = parsed.data;
+  const issues = [];
+  validateSourceConsent(taskset, issues);
+  validateDatasetArtifact(taskset, issues);
+  validateSplitIsolation(taskset, issues);
+  validatePolicyBoundary(taskset, issues);
+  validateGraders(taskset, issues);
+  validateGraderFixtures(taskset, issues);
+  validateLearningSignals(taskset, issues);
+  validateCapabilities(taskset.capabilities, issues, taskset);
+  validateWorkExecution(taskset, issues);
+  const computedHash = tasksetContentHash(taskset);
+  if (taskset.contentHash !== computedHash) {
+    issues.push({
+      code: "content_hash_mismatch",
+      severity: "error",
+      message: `Taskset contentHash is ${taskset.contentHash}, expected ${computedHash}.`,
+      path: "contentHash"
+    });
+  }
+  return {
+    valid: !issues.some((issue) => issue.severity === "error"),
+    taskset,
+    computedHash,
+    issues
+  };
+}
+function validateGraderFixtures(taskset, issues) {
+  if (!taskset.graderFixtures.length) issues.push({ code: "grader_fixtures_required", severity: "error", message: "Taskset admission requires authored grader fixtures.", path: "graderFixtures" });
+  const taskIds = new Set(taskset.tasks.map((task) => task.id));
+  const required = /* @__PURE__ */ new Set(["positive", "negative", "boundary", "adversarial", "prompt_injection", "infrastructure_failure"]);
+  for (const fixture of taskset.graderFixtures) {
+    if (!taskset.datasetArtifact && !taskIds.has(fixture.taskId)) issues.push({ code: "grader_fixture_task_missing", severity: "warning", message: `Fixture ${fixture.id} references a task outside this Taskset revision (${fixture.taskId}).`, path: `graderFixtures.${fixture.id}.taskId` });
+    required.delete(fixture.label);
+    if (fixture.label === "infrastructure_failure" && !fixture.infrastructureError) issues.push({ code: "infrastructure_fixture_error_missing", severity: "error", message: `Infrastructure fixture ${fixture.id} must declare an infrastructure error.`, path: `graderFixtures.${fixture.id}.infrastructureError` });
+  }
+  for (const label of required) issues.push({ code: "grader_fixture_missing", severity: "warning", message: `Taskset does not include the optional ${label} grader calibration fixture.`, path: "graderFixtures" });
+}
+function validateDatasetArtifact(taskset, issues) {
+  const artifact = taskset.datasetArtifact;
+  if (!artifact) return;
+  if (artifact.tasksetId !== taskset.id || artifact.tasksetRevision !== taskset.revision) {
+    issues.push({
+      code: "dataset_artifact_taskset_mismatch",
+      severity: "error",
+      message: "Dataset artifact identity does not match its Taskset revision.",
+      path: "datasetArtifact"
+    });
+  }
+  const splitTotal = Object.values(artifact.splitCounts).reduce((total, count) => total + count, 0);
+  const shardTotal = artifact.shards.reduce((total, shard) => total + shard.rowCount, 0);
+  if (splitTotal !== artifact.rowCount || shardTotal !== artifact.rowCount) {
+    issues.push({
+      code: "dataset_artifact_row_count_mismatch",
+      severity: "error",
+      message: "Dataset artifact row, split, and shard counts do not agree.",
+      path: "datasetArtifact.rowCount"
+    });
+  }
+  const shardSplitCounts = /* @__PURE__ */ new Map();
+  for (const shard of artifact.shards) {
+    shardSplitCounts.set(
+      shard.split,
+      (shardSplitCounts.get(shard.split) ?? 0) + shard.rowCount
+    );
+  }
+  for (const [split, count] of Object.entries(artifact.splitCounts)) {
+    if ((shardSplitCounts.get(split) ?? 0) !== count) {
+      issues.push({
+        code: "dataset_artifact_split_count_mismatch",
+        severity: "error",
+        message: `Dataset artifact ${split} shard counts do not match its manifest.`,
+        path: `datasetArtifact.splitCounts.${split}`
+      });
+    }
+  }
+  const { contentHash: _contentHash, ...hashable } = artifact;
+  if (contentHash(hashable) !== artifact.contentHash) {
+    issues.push({
+      code: "dataset_artifact_hash_mismatch",
+      severity: "error",
+      message: "Dataset artifact manifest content hash is invalid.",
+      path: "datasetArtifact.contentHash"
+    });
+  }
+}
+function computeTasksetHash(taskset) {
+  return tasksetContentHash(taskset);
+}
+function tasksetContentHash(taskset) {
+  const { contentHash: _contentHash, status: _status, readiness: _readiness, updatedAt: _updatedAt, ...source } = taskset;
+  return contentHash(source);
+}
+function validatePortability(capabilities) {
+  const issues = [];
+  validateCapabilities(capabilities, issues, null);
+  return issues;
+}
+function validateSourceConsent(taskset, issues) {
+  for (const [index, source] of taskset.sourceRefs.entries()) {
+    if (isTrainingSourceRef(source) && source.consent.status !== "granted") {
+      issues.push({ code: "source_consent_missing", severity: "error", message: `Source ${source.id} is not consented.`, path: `sourceRefs.${index}.consent.status` });
+    }
+    if (source.secretScanStatus !== "passed") {
+      issues.push({ code: "source_secret_scan", severity: "error", message: `Source ${source.id} did not pass secret scanning.`, path: `sourceRefs.${index}.secretScanStatus` });
+    }
+    if (source.piiScanStatus !== "passed") {
+      issues.push({ code: "source_pii_scan", severity: "error", message: `Source ${source.id} has unresolved PII policy.`, path: `sourceRefs.${index}.piiScanStatus` });
+    }
+    if (source.licensingStatus !== "approved") {
+      issues.push({ code: "source_license", severity: "error", message: `Source ${source.id} has unresolved licensing policy.`, path: `sourceRefs.${index}.licensingStatus` });
+    }
+  }
+}
+function validateSplitIsolation(taskset, issues) {
+  const clusterSplits = /* @__PURE__ */ new Map();
+  for (const task of taskset.tasks) {
+    const splits = clusterSplits.get(task.clusterKey) ?? /* @__PURE__ */ new Set();
+    splits.add(task.split);
+    clusterSplits.set(task.clusterKey, splits);
+  }
+  for (const [cluster, splits] of clusterSplits) {
+    if (splits.size > 1) {
+      issues.push({ code: "split_cluster_contamination", severity: "error", message: `Source cluster ${cluster} appears in multiple splits: ${[...splits].join(", ")}.`, path: "tasks" });
+    }
+  }
+  const frozenCount = taskset.datasetArtifact ? taskset.datasetArtifact.splitCounts.frozen_eval ?? 0 : taskset.tasks.filter((task) => task.split === "frozen_eval").length;
+  if (frozenCount === 0) issues.push({ code: "frozen_eval_missing", severity: "warning", message: "Add an independent test example before training.", path: "tasks" });
+}
+function validateWorkExecution(taskset, issues) {
+  if (taskset.environment.kind !== "work") return;
+  if (taskset.environment.entrypoint !== "openpond-work-v1") {
+    issues.push({
+      code: "work_entrypoint_invalid",
+      severity: "error",
+      message: "Work Tasksets must use the openpond-work-v1 entrypoint.",
+      path: "environment.entrypoint"
+    });
+  }
+  if (taskset.environment.stateful) {
+    issues.push({
+      code: "work_stateful_invalid",
+      severity: "error",
+      message: "Automated Work attempts must start from clean state.",
+      path: "environment.stateful"
+    });
+  }
+  const allowedTools = new Set(TASKSET_WORK_TOOL_NAMES);
+  const unknownTools = taskset.environment.toolNames.filter(
+    (name) => !allowedTools.has(name)
+  );
+  if (unknownTools.length) {
+    issues.push({
+      code: "work_tool_unknown",
+      severity: "error",
+      message: `Work Taskset declares unknown tools: ${unknownTools.join(", ")}.`,
+      path: "environment.toolNames"
+    });
+  }
+  if (!taskset.environment.toolNames.includes("work_save_output")) {
+    issues.push({
+      code: "work_output_tool_missing",
+      severity: "error",
+      message: "Work Tasksets must declare work_save_output.",
+      path: "environment.toolNames"
+    });
+  }
+  for (const lifecycle of ["create", "reset", "step", "grade", "cleanup"]) {
+    if (!taskset.environment.lifecycle.includes(lifecycle)) {
+      issues.push({
+        code: "work_lifecycle_incomplete",
+        severity: "error",
+        message: `Work Tasksets require the ${lifecycle} lifecycle stage.`,
+        path: "environment.lifecycle"
+      });
+    }
+  }
+  const sourceById = new Map(
+    taskset.sourceRefs.map((source) => [source.id, source])
+  );
+  for (const [taskIndex, task] of taskset.tasks.entries()) {
+    const assetIds = /* @__PURE__ */ new Set();
+    const fileNames = /* @__PURE__ */ new Set();
+    for (const [assetIndex, asset] of (task.assets ?? []).entries()) {
+      const path = `tasks.${taskIndex}.assets.${assetIndex}`;
+      if (assetIds.has(asset.id)) {
+        issues.push({
+          code: "work_asset_duplicate_id",
+          severity: "error",
+          message: `Task ${task.id} repeats asset id ${asset.id}.`,
+          path: `${path}.id`
+        });
+      }
+      if (fileNames.has(asset.fileName)) {
+        issues.push({
+          code: "work_asset_duplicate_name",
+          severity: "error",
+          message: `Task ${task.id} repeats staged file name ${asset.fileName}.`,
+          path: `${path}.fileName`
+        });
+      }
+      assetIds.add(asset.id);
+      fileNames.add(asset.fileName);
+      if (!task.sourceRefs.includes(asset.sourceRefId)) {
+        issues.push({
+          code: "work_asset_task_source_missing",
+          severity: "error",
+          message: `Asset ${asset.id} references source ${asset.sourceRefId} outside task ${task.id}.`,
+          path: `${path}.sourceRefId`
+        });
+      }
+      const source = sourceById.get(asset.sourceRefId);
+      if (!source) {
+        issues.push({
+          code: "work_asset_source_missing",
+          severity: "error",
+          message: `Asset ${asset.id} references missing source ${asset.sourceRefId}.`,
+          path: `${path}.sourceRefId`
+        });
+      } else if ("sourceFileHashes" in source && !source.sourceFileHashes.includes(asset.sha256)) {
+        issues.push({
+          code: "work_asset_hash_unregistered",
+          severity: "error",
+          message: `Asset ${asset.id} hash is not registered by source ${asset.sourceRefId}.`,
+          path: `${path}.sha256`
+        });
+      }
+      if (source && "kind" in source && source.kind === "uploaded_file" && !source.originalFileNames.includes(asset.fileName)) {
+        issues.push({
+          code: "work_asset_name_unregistered",
+          severity: "error",
+          message: `Asset ${asset.id} file name is not registered by source ${asset.sourceRefId}.`,
+          path: `${path}.fileName`
+        });
+      }
+      if (source && "kind" in source && source.kind === "uploaded_file" && !source.mediaTypes.includes(asset.mediaType)) {
+        issues.push({
+          code: "work_asset_media_type_unregistered",
+          severity: "error",
+          message: `Asset ${asset.id} media type is not registered by source ${asset.sourceRefId}.`,
+          path: `${path}.mediaType`
+        });
+      }
+      if (asset.split !== task.split) {
+        issues.push({
+          code: "work_asset_split_mismatch",
+          severity: "error",
+          message: `Asset ${asset.id} is assigned to ${asset.split}, not task split ${task.split}.`,
+          path: `${path}.split`
+        });
+      }
+    }
+    const outputPaths = /* @__PURE__ */ new Set();
+    for (const [outputIndex, output] of (task.requiredOutputs ?? []).entries()) {
+      const normalized = output.path.replaceAll("\\", "/");
+      const path = `tasks.${taskIndex}.requiredOutputs.${outputIndex}.path`;
+      if (outputPaths.has(normalized)) {
+        issues.push({
+          code: "work_output_duplicate_path",
+          severity: "error",
+          message: `Task ${task.id} repeats required output path ${normalized}.`,
+          path
+        });
+      }
+      outputPaths.add(normalized);
+    }
+    if ((task.requiredOutputs ?? []).length === 0) {
+      issues.push({
+        code: "work_output_missing",
+        severity: "error",
+        message: `Work task ${task.id} must declare at least one required output.`,
+        path: `tasks.${taskIndex}.requiredOutputs`
+      });
+    }
+  }
+}
+function validatePolicyBoundary(taskset, issues) {
+  const visible = new Set(taskset.policy.policyVisibleFields);
+  for (const field of taskset.policy.privilegedFields) {
+    if (visible.has(field)) issues.push({ code: "privileged_field_visible", severity: "error", message: `Field ${field} is both policy-visible and privileged.`, path: "policy" });
+  }
+  for (const task of taskset.tasks) {
+    if (task.privilegedContextRef && Object.keys(task.policyVisibleContext).includes(task.privilegedContextRef)) {
+      issues.push({ code: "privileged_context_leak", severity: "error", message: `Task ${task.id} exposes its privileged context reference.`, path: `tasks.${task.id}.policyVisibleContext` });
+    }
+  }
+}
+function validateGraders(taskset, issues) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const grader of taskset.graders) {
+    if (ids.has(grader.id)) issues.push({ code: "grader_duplicate", severity: "error", message: `Duplicate grader id ${grader.id}.`, path: "graders" });
+    ids.add(grader.id);
+    if (grader.kind === "model_judge" && grader.rewardEligible && grader.calibrationStatus !== "passed") {
+      issues.push({ code: "judge_calibration_pending", severity: "warning", message: `Model judge ${grader.id} is selected for reward without a passing advisory calibration report.`, path: `graders.${grader.id}` });
+    }
+    if (grader.kind === "model_judge" && grader.calibrationStatus === "passed" && typeof grader.metadata.calibrationEvidenceHash !== "string") {
+      issues.push({ code: "judge_calibration_evidence_missing", severity: "warning", message: `Model judge ${grader.id} declares calibration without an OpenPond fixture evidence hash.`, path: `graders.${grader.id}.metadata.calibrationEvidenceHash` });
+    }
+    if (grader.kind === "human" && grader.rewardEligible) {
+      issues.push({ code: "human_online_reward", severity: "error", message: `Human grader ${grader.id} cannot be an online optimizer reward.`, path: `graders.${grader.id}` });
+    }
+  }
+}
+function validateLearningSignals(taskset, issues) {
+  const taskIds = new Set(taskset.tasks.map((task) => task.id));
+  const sourceIds = new Set(taskset.sourceRefs.map((source) => source.id));
+  for (const signal of [
+    ...taskset.learningSignals.demonstrations,
+    ...taskset.learningSignals.preferences,
+    ...taskset.learningSignals.corrections,
+    ...taskset.learningSignals.feedback,
+    ...taskset.learningSignals.rewards,
+    ...taskset.learningSignals.labels
+  ]) {
+    if (signal.taskId && !taskset.datasetArtifact && !taskIds.has(signal.taskId)) {
+      issues.push({ code: "learning_signal_task_missing", severity: "error", message: `Signal ${signal.id} references missing task ${signal.taskId}.`, path: `learningSignals.${signal.kind}.${signal.id}.taskId` });
+    }
+    if (signal.sourceRefs.some((sourceId) => !sourceIds.has(sourceId))) {
+      issues.push({ code: "learning_signal_source_missing", severity: "error", message: `Signal ${signal.id} references a source outside the Dataset.`, path: `learningSignals.${signal.kind}.${signal.id}.sourceRefs` });
+    }
+  }
+  for (const preference of taskset.learningSignals.preferences) {
+    if (preference.chosen.trim() === preference.rejected.trim()) {
+      issues.push({ code: "preference_pair_identical", severity: "error", message: `Preference ${preference.id} has identical chosen and rejected responses.`, path: `learningSignals.preferences.${preference.id}` });
+    }
+  }
+  for (const reward of taskset.learningSignals.rewards) {
+    if (!reward.executable) {
+      issues.push({ code: "reward_not_executable", severity: "warning", message: `Reward ${reward.id} is a reviewed specification but has no executable verifier yet.`, path: `learningSignals.rewards.${reward.id}.executable` });
+    }
+  }
+}
+function validateCapabilities(capabilities, issues, taskset) {
+  if (!capabilities.exportable && capabilities.portabilityBlockers.length === 0) {
+    issues.push({ code: "portability_reason_missing", severity: "error", message: "Non-exportable Tasksets must declare a portability blocker.", path: "capabilities.portabilityBlockers" });
+  }
+  if (capabilities.compatibleMethods.includes("grpo") && !capabilities.rewardKinds.some((kind) => kind === "exact" || kind === "deterministic" || kind === "model_judge")) {
+    issues.push({ code: "grpo_reward_missing", severity: "error", message: "GRPO compatibility requires a scalar reward kind.", path: "capabilities.rewardKinds" });
+  }
+  if (taskset?.capabilities.compatibleMethods.includes("sft") && taskset.learningSignals.demonstrations.length === 0) {
+    issues.push({ code: "sft_demonstrations_missing", severity: "error", message: "SFT compatibility requires approved demonstrations.", path: "learningSignals.demonstrations" });
+  }
+  if (taskset?.capabilities.compatibleMethods.includes("dpo") && taskset.learningSignals.preferences.length === 0) {
+    issues.push({ code: "dpo_preferences_missing", severity: "error", message: "DPO compatibility requires chosen and rejected response pairs.", path: "learningSignals.preferences" });
+  }
+  if (taskset && (taskset.capabilities.compatibleMethods.includes("grpo") || taskset.capabilities.compatibleMethods.includes("ppo")) && !taskset.learningSignals.rewards.some((reward) => reward.executable)) {
+    issues.push({ code: "online_reward_not_executable", severity: "error", message: "GRPO/PPO compatibility requires an executable scalar reward.", path: "learningSignals.rewards" });
+  }
+}
+
+// src/taskset-package-learning.ts
+import { z as z6 } from "zod";
+import {
+  TaskBatchSchema,
+  TaskEvidenceSchema,
+  TaskAdmissionDecisionSchema,
+  LearningSourceSchema,
+  LearningTextAssetSchema,
+  assertLearningContentHash,
+  compileTaskBatch,
+  learningRef,
+  sameLearningRef,
+  taskBatchPackageMetadata,
+  verifyLearningTextAsset
+} from "@openpond/evals/learning";
+var TasksetPackageLearningResourcesSchema = z6.object({
+  batch: TaskBatchSchema,
+  evidence: z6.array(TaskEvidenceSchema).min(1).max(1e4),
+  decisions: z6.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
+  sources: z6.array(LearningSourceSchema).min(1).max(1e4),
+  assets: z6.array(LearningTextAssetSchema).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 (!sameLearningRef(learningRef(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) {
+      assertLearningContentHash(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) => sameLearningRef(learningRef(source2), evidence.source));
+    if (!source || !sameLearningRef(source.taskDefinition, learningRef(metadata.definition))) throw new Error("Taskset evidence source differs from its task definition.");
+  }
+  if (resources.sources.some((source) => !resources.evidence.some((evidence) => sameLearningRef(evidence.source, learningRef(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.");
+    verifyLearningTextAsset(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 z7 } from "zod";
+var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
+var TasksetPackageFileSchema = z7.object({
+  asset: ImmutableAssetRefSchema,
+  base64: z7.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 = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+  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 LearningTextAssetSchema2, sealLearningContent } 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 LearningTextAssetSchema2.parse(sealLearningContent({ 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-package-contracts.ts
+import { z as z8 } from "zod";
+import { EnvironmentReleaseSchema, VerifierSetReleaseSchema, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
+import { assertTasksetRelease, TasksetReleaseSchema } from "@openpond/evals/tasksets";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
+
+// src/model-taskset-authoring-lineage.ts
+import { sameLearningRef as sameLearningRef2 } 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 ? !sameLearningRef2(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 = z8.object({
+  schemaVersion: z8.literal("openpond.tasksetPackage.v1"),
+  taskset: TasksetReleaseSchema,
+  environment: EnvironmentReleaseSchema,
+  verifierSet: VerifierSetReleaseSchema,
+  files: z8.array(TasksetPackageFileSchema).max(1e4),
+  modelResources: BoundModelResourcesSchema.optional(),
+  learningResources: TasksetPackageLearningResourcesSchema.optional()
+}).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z8.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 = z8.object({ instructions: z8.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
+  return authoring.instructions ?? "";
+}
+function validateTasksetPackage(value) {
+  assertBoundedTaskJson(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;
+  assertTasksetRelease(taskset);
+  const authoring = assertModelTasksetAuthoring(taskset);
+  if (authoring && (result.modelResources || result.learningResources)) throw new Error("Taskset package cannot declare competing authoring graphs.");
+  if (!verifyEnvironmentRelease(environment) || !verifyVerifierSetRelease(verifierSet) || !same(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same(taskset.environment, environment.contract) || !same(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 || !same(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 z8.array(z8.object({ path: z8.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 (!same(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);
+  return result;
+}
+function createTasksetPackage(value) {
+  assertBoundedTaskJson(value, MAX_TASKSET_PACKAGE_BYTES);
+  const content = TasksetPackageContentSchema.parse(value);
+  return validateTasksetPackage({ ...content, contentHash: contentHash(content) });
+}
+function same(left, right) {
+  return contentHash({ value: left }) === contentHash({ value: right });
+}
+
+export {
+  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,
+  TASKSET_WORK_TOOL_NAMES,
+  TasksetStatusSchema,
+  DatasetBuildIntentSchema,
+  DatasetBuildSpecificationSchema,
+  GeneratedTaskFileSchema,
+  TrainingPathRecommendationSchema,
+  TrainingMethodReadinessReasonCodeSchema,
+  TrainingMethodReadinessSchema,
+  TasksetReadinessFindingSchema,
+  TasksetReadinessReportSchema,
+  AuthoringRepairSchema,
+  AuthoringProvenanceSchema,
+  TasksetSchema,
+  isTrainingSourceRef,
+  validateTaskset,
+  computeTasksetHash,
+  validatePortability,
+  TasksetPackageLearningResourcesSchema,
+  learningPackageContextFiles,
+  validateTasksetLearningResources,
+  modelAuthoredTasksetId,
+  assertModelTasksetAuthoring,
+  MAX_TASKSET_PACKAGE_BYTES,
+  TasksetPackageFileSchema,
+  decodeTasksetPackageFile,
+  resolveTasksetPackageExecution,
+  createTasksetPackageExecutionFile,
+  TasksetPackageContentSchema,
+  TasksetPackageSchema,
+  tasksetPackageRewardBinding,
+  resolveTasksetPackageInstructions,
+  validateTasksetPackage,
+  createTasksetPackage
+};
+//# sourceMappingURL=chunk-QFT2MCIC.js.map