openpond-sdk 0.2.3 → 0.2.5

package/dist/taskset-packages.js

@@ -1,5 +1,5 @@
 // src/taskset-package-contracts.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 
 // ../harness/dist/common.js
 import { z } from "zod";
@@ -1859,6 +1859,63 @@ import { validateTaskValue } from "@openpond/evals/task-schema";
 // src/model-projects.ts
 import { z as z11 } from "zod";
 import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+
+// src/protocol.ts
+var OpenPondProtocolError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OpenPondProtocolError";
+    this.code = code;
+  }
+};
+function canonicalJson2(value) {
+  return JSON.stringify(normalizeCanonicalJson(value));
+}
+function normalizeCanonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new OpenPondProtocolError(
+        "non_json_value",
+        "Canonical JSON cannot contain a non-finite number."
+      );
+    }
+    return Object.is(value, -0) ? 0 : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeCanonicalJson(entry));
+  }
+  if (typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new OpenPondProtocolError(
+        "non_json_value",
+        "Canonical JSON accepts only plain objects."
+      );
+    }
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      const entry = value[key];
+      if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") {
+        throw new OpenPondProtocolError(
+          "non_json_value",
+          `Canonical JSON cannot contain ${typeof entry} at ${key}.`
+        );
+      }
+      result[key] = normalizeCanonicalJson(entry);
+    }
+    return result;
+  }
+  throw new OpenPondProtocolError(
+    "non_json_value",
+    `Canonical JSON cannot contain ${typeof value}.`
+  );
+}
+
+// src/model-projects.ts
 var IdSchema = z11.string().trim().min(1).max(500);
 var HashSchema = z11.string().regex(/^[a-f0-9]{64}$/);
 var TimestampSchema = z11.string().datetime({ offset: true });
@@ -2189,22 +2246,381 @@ function validateModelTasksetPackage(value) {
   return result;
 }
 
+// src/taskset-package-contracts.ts
+import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
+
+// src/taskset-package-learning.ts
+import { z as z16 } 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";
+
+// src/training.ts
+import { z as z15 } from "zod";
+var IdSchema2 = z15.string().trim().min(1).max(500);
+var HashSchema3 = z15.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema2 = z15.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z15.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z15.string().trim().min(1).max(500),
+  sourceManifest: ModelProjectImmutableRefSchema,
+  payload: z15.unknown(),
+  contentHash: HashSchema3
+}).strict();
+var TrainingInputArtifactSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingInputArtifact.v2"),
+  kind: z15.enum(["portable_training_bundle", "reward_model_dataset"]),
+  sourceManifest: ModelProjectImmutableRefSchema,
+  artifactRef: z15.string().trim().min(1).max(2e3),
+  contentHash: HashSchema3,
+  sizeBytes: z15.number().int().positive(),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingJobKindSchema = z15.enum([
+  "reward_model_train",
+  "policy_optimize"
+]);
+var TrainingJobStateSchema = z15.enum([
+  "queued",
+  "admitting",
+  "provisioning",
+  "running",
+  "stopping",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled"
+]);
+var TrainingCapabilityRequirementSchema = z15.object({
+  id: IdSchema2,
+  version: z15.string().trim().min(1).max(200).nullable().default(null),
+  required: z15.boolean().default(true)
+}).strict();
+var TrainingJobSourceSchema = z15.object({
+  modelProject: z15.object({
+    id: IdSchema2,
+    portableProjectId: IdSchema2,
+    revision: z15.number().int().positive(),
+    contentHash: HashSchema3
+  }).strict(),
+  harnessRunManifest: ModelProjectImmutableRefSchema,
+  harnessRelease: ModelProjectImmutableRefSchema,
+  taskset: ModelProjectVersionedRefSchema,
+  tasksetRelease: ModelProjectImmutableRefSchema,
+  dataset: ModelProjectImmutableRefSchema,
+  evidenceSets: z15.array(ModelProjectImmutableRefSchema).max(1e4)
+}).strict();
+var RewardModelTrainingRequestSchema = z15.object({
+  kind: z15.literal("reward_model_train"),
+  baseModel: ModelProjectBaseModelSchema,
+  preferenceDatasetRelease: ModelProjectImmutableRefSchema,
+  processorRelease: ModelProjectImmutableRefSchema,
+  recipe: z15.object({
+    schemaVersion: z15.literal("openpond.rewardModelRecipe.v1"),
+    method: z15.literal("reward_model"),
+    parameterization: z15.literal("lora_with_scalar_head")
+  }).catchall(z15.unknown())
+}).strict();
+var DeterministicRewardSourceSchema = z15.object({
+  kind: z15.literal("deterministic"),
+  grader: ModelProjectImmutableRefSchema,
+  composer: ModelProjectImmutableRefSchema.nullable().default(null)
+}).strict();
+var LearnedRewardSourceSchema = z15.object({
+  kind: z15.literal("learned_reward"),
+  rewardModelVersion: ModelProjectImmutableRefSchema,
+  qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
+  evaluationReferences: z15.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z15.object({
+    artifactRef: z15.string().trim().min(1).max(2e3),
+    contentHash: HashSchema3,
+    executionReceipt: ModelProjectImmutableRefSchema
+  }).strict(),
+  processorRelease: ModelProjectImmutableRefSchema,
+  rewardComposerRelease: ModelProjectImmutableRefSchema
+}).strict();
+var PolicyOptimizationRequestSchema = z15.object({
+  kind: z15.literal("policy_optimize"),
+  baseModel: ModelProjectBaseModelSchema,
+  recipe: ModelProjectRecipeDocumentSchema,
+  rewardSource: z15.discriminatedUnion("kind", [
+    DeterministicRewardSourceSchema,
+    LearnedRewardSourceSchema
+  ]),
+  resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
+}).strict();
+var TrainingJobRequestSchema = z15.discriminatedUnion("kind", [
+  RewardModelTrainingRequestSchema,
+  PolicyOptimizationRequestSchema
+]);
+var TrainingJobApprovalSchema = z15.object({
+  approvalHash: HashSchema3,
+  approvedAt: TimestampSchema2,
+  exportApproved: z15.boolean(),
+  maximumSpendUsd: z15.number().nonnegative(),
+  retentionDays: z15.number().int().nonnegative().nullable(),
+  region: z15.string().trim().min(1).max(200).nullable().default(null)
+}).strict();
+var TrainingJobSubmissionSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z15.string().trim().min(1).max(500),
+  name: z15.string().trim().min(1).max(200),
+  source: TrainingJobSourceSchema,
+  job: TrainingJobRequestSchema,
+  requestedCapabilities: z15.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z15.enum(["fast", "balanced", "economical"]),
+  budget: z15.object({
+    maximumSpendUsd: z15.number().nonnegative(),
+    maximumWallSeconds: z15.number().int().positive()
+  }).strict(),
+  approval: TrainingJobApprovalSchema,
+  contentHash: HashSchema3
+}).strict().superRefine((submission, context) => {
+  if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
+    context.addIssue({
+      code: "custom",
+      path: ["approval", "maximumSpendUsd"],
+      message: "Approved spend must equal the immutable Job budget."
+    });
+  }
+});
+var TrainingJobSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJob.v2"),
+  id: IdSchema2,
+  teamId: IdSchema2,
+  kind: TrainingJobKindSchema,
+  modelProjectId: IdSchema2,
+  portableProjectId: IdSchema2,
+  sourceProjectRevision: z15.number().int().positive(),
+  submissionHash: HashSchema3,
+  state: TrainingJobStateSchema,
+  phase: z15.string().trim().min(1).max(200),
+  version: z15.number().int().nonnegative(),
+  progress: z15.number().min(0).max(1),
+  rolloutProgress: z15.object({
+    groupsCompleted: z15.number().int().nonnegative(),
+    groupsTarget: z15.number().int().nonnegative(),
+    optimizerUpdatesApplied: z15.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z15.number().int().nonnegative()
+  }).strict(),
+  accruedSpendUsd: z15.number().nonnegative(),
+  terminalReason: z15.string().trim().min(1).max(5e3).nullable(),
+  createdAt: TimestampSchema2,
+  updatedAt: TimestampSchema2,
+  completedAt: TimestampSchema2.nullable()
+}).strict();
+var TrainingJobPageSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobPage.v2"),
+  jobs: z15.array(TrainingJobSchema).max(1e3),
+  nextCursor: z15.string().trim().min(1).max(2e3).nullable()
+}).strict();
+var TrainingJobEventSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobEvent.v2"),
+  id: IdSchema2,
+  jobId: IdSchema2,
+  sequence: z15.number().int().nonnegative(),
+  type: IdSchema2,
+  phase: z15.string().trim().min(1).max(200),
+  message: z15.string().trim().min(1).max(5e3).nullable(),
+  data: z15.record(z15.string(), z15.unknown()).default({}),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingJobLogSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobLog.v2"),
+  jobId: IdSchema2,
+  sequence: z15.number().int().nonnegative(),
+  level: z15.enum(["debug", "info", "warning", "error"]),
+  message: z15.string().max(2e4),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingJobControlRequestSchema = z15.object({ expectedVersion: z15.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobOutput.v2"),
+  id: IdSchema2,
+  jobId: IdSchema2,
+  kind: z15.enum([
+    "checkpoint",
+    "adapter",
+    "scorer",
+    "metrics",
+    "evaluation",
+    "trace",
+    "receipt"
+  ]),
+  artifactRef: z15.string().trim().min(1).max(2e3),
+  contentHash: HashSchema3,
+  sizeBytes: z15.number().int().nonnegative(),
+  metadata: z15.record(z15.string(), z15.unknown()).default({}),
+  createdAt: TimestampSchema2
+}).strict();
+var TrainingExecutionReceiptSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingExecutionReceipt.v2"),
+  id: IdSchema2,
+  teamId: IdSchema2,
+  jobId: IdSchema2,
+  submissionHash: HashSchema3,
+  manifestHash: HashSchema3,
+  recipeHash: HashSchema3,
+  capabilityHash: HashSchema3,
+  runtimeRelease: ModelProjectImmutableRefSchema,
+  inputs: z15.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z15.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z15.number().nonnegative(),
+  durationSeconds: z15.number().nonnegative(),
+  cleanupComplete: z15.boolean(),
+  issuer: IdSchema2,
+  issuedAt: TimestampSchema2,
+  signature: z15.string().trim().min(1).max(1e4).nullable()
+}).strict();
+var TrainingJobOutputsSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z15.array(TrainingJobOutputSchema).max(1e4),
+  receipt: TrainingExecutionReceiptSchema.nullable()
+}).strict();
+var TrainingApiErrorSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingApiError.v2"),
+  code: z15.string().trim().min(1).max(200),
+  message: z15.string().trim().min(1).max(5e3),
+  retryable: z15.boolean().default(false),
+  requestId: z15.string().trim().min(1).max(500).nullable().default(null),
+  details: z15.record(z15.string(), z15.unknown()).default({})
+}).strict();
+var TrainingCapabilitiesSchema = z15.object({
+  schemaVersion: z15.literal("openpond.trainingCapabilities.v2"),
+  capabilityHash: HashSchema3,
+  jobKinds: z15.array(TrainingJobKindSchema),
+  methods: z15.array(z15.string().trim().min(1).max(200)),
+  placements: z15.array(
+    z15.enum(["local", "remote", "colocated", "provider_native"])
+  ),
+  controls: z15.object({
+    cancel: z15.boolean(),
+    stopAfterGroup: z15.boolean(),
+    resumeFromCheckpoint: z15.boolean()
+  }).strict(),
+  limits: z15.object({
+    maximumSpendUsd: z15.number().nonnegative(),
+    maximumWallSeconds: z15.number().int().positive(),
+    maximumArtifactBytes: z15.number().int().positive()
+  }).strict(),
+  checkedAt: TimestampSchema2,
+  expiresAt: TimestampSchema2
+}).strict();
+
+// src/taskset-package-learning.ts
+var TasksetPackageLearningResourcesSchema = z16.object({
+  batch: TaskBatchSchema,
+  evidence: z16.array(TaskEvidenceSchema).min(1).max(1e4),
+  decisions: z16.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
+  sources: z16.array(LearningSourceSchema).min(1).max(1e4),
+  assets: z16.array(LearningTextAssetSchema2).max(1e3)
+}).strict();
+function learningPackageContextFiles(resources) {
+  return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
+    const text = canonicalJson2(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-contracts.ts
 var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z15.object({
+var TasksetPackageFileSchema = z17.object({
   asset: ImmutableAssetRefSchema,
-  base64: z15.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
+  base64: z17.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
 }).strict();
 var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z15.object({
-  schemaVersion: z15.literal("openpond.tasksetPackage.v1"),
+var TasksetPackageContentSchema = z17.object({
+  schemaVersion: z17.literal("openpond.tasksetPackage.v1"),
   taskset: TasksetReleaseSchema2,
   environment: EnvironmentReleaseSchema3,
   verifierSet: VerifierSetReleaseSchema3,
-  files: z15.array(TasksetPackageFileSchema).max(1e4),
-  modelResources: BoundModelResourcesSchema.optional()
+  files: z17.array(TasksetPackageFileSchema).max(1e4),
+  modelResources: BoundModelResourcesSchema.optional(),
+  learningResources: TasksetPackageLearningResourcesSchema.optional()
 }).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z15.string().regex(/^[a-f0-9]{64}$/) }).strict();
+var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z17.string().regex(/^[a-f0-9]{64}$/) }).strict();
+function tasksetPackageRewardBinding(value) {
+  return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
+}
 function decodeTasksetPackageFile(value) {
   const file = TasksetPackageFileSchema.parse(value);
   const raw = atob(file.base64);
@@ -2250,11 +2666,18 @@ function validateTasksetPackage(value) {
   }
   for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
     if (declarations === void 0) continue;
-    for (const resource of z15.array(z15.object({ path: z15.string().min(1) }).passthrough()).parse(declarations)) {
+    for (const resource of z17.array(z17.object({ path: z17.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.modelResources) {
+  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)) {
@@ -2272,45 +2695,45 @@ function same2(left, right) {
 }
 
 // src/taskset-package-client.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // src/taskset-catalog.ts
-import { z as z16 } from "zod";
-var IdSchema2 = z16.string().trim().min(1).max(500);
-var HashSchema3 = z16.string().regex(/^[a-f0-9]{64}$/);
-var TasksetCatalogReleaseRefSchema = z16.object({ id: IdSchema2, revision: z16.number().int().positive(), contentHash: HashSchema3 }).strict();
-var HostedTasksetSummarySchema = z16.object({
-  schemaVersion: z16.literal("openpond.hostedTasksetSummary.v1"),
-  id: IdSchema2,
-  teamId: IdSchema2,
+import { z as z18 } from "zod";
+var IdSchema3 = z18.string().trim().min(1).max(500);
+var HashSchema4 = z18.string().regex(/^[a-f0-9]{64}$/);
+var TasksetCatalogReleaseRefSchema = z18.object({ id: IdSchema3, revision: z18.number().int().positive(), contentHash: HashSchema4 }).strict();
+var HostedTasksetSummarySchema = z18.object({
+  schemaVersion: z18.literal("openpond.hostedTasksetSummary.v1"),
+  id: IdSchema3,
+  teamId: IdSchema3,
   release: TasksetCatalogReleaseRefSchema,
-  name: z16.string().min(1).max(500),
-  description: z16.string().max(2e4),
-  taskCount: z16.number().int().nonnegative(),
-  buildIntent: z16.string().min(1).max(100),
-  methodHint: z16.string().min(1).max(100).nullable(),
-  packageBytes: z16.number().int().nonnegative().nullable(),
-  storedBytes: z16.number().int().nonnegative().nullable(),
-  createdAt: z16.string().datetime({ offset: true })
-}).strict();
-var TasksetCatalogQuerySchema = z16.object({
-  afterId: IdSchema2.optional(),
-  limit: z16.number().int().min(1).max(100).default(30),
-  modelProjectId: IdSchema2.optional()
-}).strict();
-var TasksetCatalogPageSchema = z16.object({
-  items: z16.array(HostedTasksetSummarySchema).max(100),
-  nextCursor: IdSchema2.nullable()
-}).strict();
-var TasksetCatalogErrorSchema = z16.object({
-  code: z16.string().min(1),
-  message: z16.string().min(1)
+  name: z18.string().min(1).max(500),
+  description: z18.string().max(2e4),
+  taskCount: z18.number().int().nonnegative(),
+  buildIntent: z18.string().min(1).max(100),
+  methodHint: z18.string().min(1).max(100).nullable(),
+  packageBytes: z18.number().int().nonnegative().nullable(),
+  storedBytes: z18.number().int().nonnegative().nullable(),
+  createdAt: z18.string().datetime({ offset: true })
+}).strict();
+var TasksetCatalogQuerySchema = z18.object({
+  afterId: IdSchema3.optional(),
+  limit: z18.number().int().min(1).max(100).default(30),
+  modelProjectId: IdSchema3.optional()
+}).strict();
+var TasksetCatalogPageSchema = z18.object({
+  items: z18.array(HostedTasksetSummarySchema).max(100),
+  nextCursor: IdSchema3.nullable()
+}).strict();
+var TasksetCatalogErrorSchema = z18.object({
+  code: z18.string().min(1),
+  message: z18.string().min(1)
 }).strict();
 
 // src/taskset-package-client.ts
-import { learningRef as learningRef3 } from "@openpond/evals/learning";
-var IdSchema3 = z17.string().trim().min(1).max(500);
-var HashSchema4 = z17.string().regex(/^[a-f0-9]{64}$/);
+import { learningRef as learningRef4 } from "@openpond/evals/learning";
+var IdSchema4 = z19.string().trim().min(1).max(500);
+var HashSchema5 = z19.string().regex(/^[a-f0-9]{64}$/);
 var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
   portableProjectId: true,
   name: true,
@@ -2320,35 +2743,35 @@ var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
   sourceRevision: true,
   sourceUpdatedAt: true
 }).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true, recipe: true }) }).strict();
-var TasksetPackagePublicationSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackagePublication.v1"),
-  operationId: IdSchema3,
-  modelProjectId: IdSchema3,
-  expectedProjectEtag: HashSchema4.nullable(),
-  name: z17.string().trim().min(1).max(200),
-  description: z17.string().max(5e3),
-  buildIntent: z17.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
-  methodHint: z17.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
+var TasksetPackagePublicationSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackagePublication.v1"),
+  operationId: IdSchema4,
+  modelProjectId: IdSchema4,
+  expectedProjectEtag: HashSchema5.nullable(),
+  name: z19.string().trim().min(1).max(200),
+  description: z19.string().max(5e3),
+  buildIntent: z19.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
+  methodHint: z19.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
   package: TasksetPackageSchema,
   modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),
-  selection: z17.enum(["select", "attach"]).optional()
+  selection: z19.enum(["select", "attach"]).optional()
 }).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace Model configuration.");
-var TasksetPackageReceiptSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackageReceipt.v1"),
-  teamId: IdSchema3,
-  modelProjectId: IdSchema3,
-  operationId: IdSchema3,
+var TasksetPackageReceiptSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackageReceipt.v1"),
+  teamId: IdSchema4,
+  modelProjectId: IdSchema4,
+  operationId: IdSchema4,
   taskset: TasksetCatalogReleaseRefSchema,
-  packageHash: HashSchema4,
-  hostedTasksetId: IdSchema3,
-  projectEtag: HashSchema4,
+  packageHash: HashSchema5,
+  hostedTasksetId: IdSchema4,
+  projectEtag: HashSchema5,
   project: HostedModelProjectSummarySchema.optional(),
-  selection: z17.enum(["select", "attach"]).optional()
+  selection: z19.enum(["select", "attach"]).optional()
 }).strict();
-var TasksetPackageReadbackSchema = z17.object({
-  schemaVersion: z17.literal("openpond.tasksetPackageReadback.v1"),
-  teamId: IdSchema3,
-  modelProjectId: IdSchema3,
+var TasksetPackageReadbackSchema = z19.object({
+  schemaVersion: z19.literal("openpond.tasksetPackageReadback.v1"),
+  teamId: IdSchema4,
+  modelProjectId: IdSchema4,
   package: TasksetPackageSchema
 }).strict();
 var OpenPondTasksetPackageError = class extends Error {
@@ -2381,10 +2804,11 @@ var OpenPondTasksetPackageClient = class {
     if (request.modelConfiguration) {
       const expected = request.modelConfiguration;
       const project = receipt.project;
+      const binding = tasksetPackageRewardBinding(request.package);
       const setup = HostedModelProjectTrainingSetupSchema.parse({
         ...expected.trainingSetup,
-        tasksetRef: learningRef3(release),
-        rewardBindingRef: request.package.modelResources ? learningRef3(request.package.modelResources.rewardBinding) : null,
+        tasksetRef: learningRef4(release),
+        rewardBindingRef: binding ? learningRef4(binding) : null,
         tasksetRelease: null,
         recipe: null
       });
@@ -2395,9 +2819,9 @@ var OpenPondTasksetPackageClient = class {
     return receipt;
   }
   async get(modelProjectId, reference, options = {}) {
-    const project = IdSchema3.parse(modelProjectId);
+    const project = IdSchema4.parse(modelProjectId);
     const ref = TasksetCatalogReleaseRefSchema.parse(reference);
-    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema4.parse(options.expectedPackageHash);
+    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema5.parse(options.expectedPackageHash);
     const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, "GET", void 0, options.signal));
     const taskset = response.package.taskset;
     if (response.teamId !== this.#options.teamId || response.modelProjectId !== project || taskset.id !== ref.id || taskset.revision !== ref.revision || taskset.contentHash !== ref.contentHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the requested release and owner.");
@@ -2434,25 +2858,320 @@ var OpenPondTasksetPackageClient = class {
     }
     const payload = JSON.parse(text);
     if (!response.ok) {
-      const error = z17.object({ code: z17.string(), message: z17.string() }).safeParse(payload);
+      const error = z19.object({ code: z19.string(), message: z19.string() }).safeParse(payload);
       throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : "package_request_failed", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);
     }
     return payload;
   }
 };
+
+// src/model-batch-review.ts
+import {
+  LearningDomainError as LearningDomainError2,
+  learningRef as learningRef6,
+  sameLearningRef as sameLearningRef4,
+  requireLearningRelease,
+  requireLearningResource,
+  taskBatchPackageMetadata as taskBatchPackageMetadata4
+} from "@openpond/evals/learning";
+
+// src/model-batch-review-contracts.ts
+import { z as z20 } from "zod";
+import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceSchema as LearningSourceSchema2, TaskEvidenceSchema as TaskEvidenceSchema2, TaskFeedbackSchema, TaskDefinitionSchema as TaskDefinitionSchema2, TaskAdmissionDecisionSchema as TaskAdmissionDecisionSchema2 } from "@openpond/evals/learning";
+import { RewardBindingSchema as RewardBindingSchema2 } from "@openpond/evals/rewards";
+var ReleaseIdSchema2 = LearningRevisionRefSchema.shape.id;
+var ModelBatchReviewInspectionSchema = z20.object({
+  schemaVersion: z20.literal("openpond.modelBatchReviewInspection.v1"),
+  packageHash: z20.string().regex(/^[a-f0-9]{64}$/),
+  definition: TaskDefinitionSchema2,
+  binding: RewardBindingSchema2,
+  evidence: z20.array(TaskEvidenceSchema2).min(1).max(1e4),
+  decisions: z20.array(TaskAdmissionDecisionSchema2).min(1).max(1e4)
+}).strict();
+var ModelBatchReviewRequestSchema = z20.object({
+  schemaVersion: z20.literal("openpond.modelBatchReviewRequest.v1"),
+  operationId: ReleaseIdSchema2,
+  modelId: ReleaseIdSchema2,
+  expectedModelRevision: z20.number().int().positive(),
+  tasksetRef: LearningRevisionRefSchema,
+  rewardBindingRef: LearningRevisionRefSchema.nullable(),
+  definition: z20.object({
+    name: z20.string().trim().min(1).max(500).optional(),
+    instructions: z20.string().trim().min(1).max(2e4).optional(),
+    inputSchema: LearningJsonObjectSchema.optional(),
+    outputSchema: LearningJsonObjectSchema.optional()
+  }).strict(),
+  examples: z20.array(z20.object({
+    evidence: LearningRevisionRefSchema,
+    input: LearningJsonObjectSchema.optional(),
+    expected: LearningJsonObjectSchema.nullable().optional(),
+    evaluatorContext: LearningJsonObjectSchema.nullable().optional(),
+    proposedTarget: LearningJsonObjectSchema.nullable().optional()
+  }).strict()).max(1e4)
+}).strict();
+var ModelBatchReviewReceiptSchema = z20.object({
+  schemaVersion: z20.literal("openpond.modelBatchReviewReceipt.v1"),
+  operationId: ReleaseIdSchema2,
+  modelId: ReleaseIdSchema2,
+  source: LearningSourceSchema2,
+  evidence: z20.array(TaskEvidenceSchema2).min(1).max(1e4),
+  proposals: z20.array(TaskFeedbackSchema).max(1e4)
+}).strict();
+
+// src/model-batch-review-preparation.ts
+import {
+  LearningDomainError,
+  LearningSourceSchema as LearningSourceSchema3,
+  TaskDefinitionSchema as TaskDefinitionSchema3,
+  TaskEvidenceSchema as TaskEvidenceSchema3,
+  TaskFeedbackSchema as TaskFeedbackSchema2,
+  assertLearningContentHash as assertLearningContentHash3,
+  learningEvidenceId,
+  learningRef as learningRef5,
+  sameLearningRef as sameLearningRef3,
+  sealLearningContent as sealLearningContent4,
+  taskBatchPackageMetadata as taskBatchPackageMetadata3,
+  verifyLearningTextAsset as verifyLearningTextAsset5
+} from "@openpond/evals/learning";
+import { compileBoundGraders as compileBoundGraders2, createRewardBinding, createRewardRelease, resolveBoundRewards } from "@openpond/evals/rewards";
+function prepareModelBatchReview(input) {
+  const { request, package: value } = input;
+  const learning = value.learningResources;
+  if (!learning) throw new LearningDomainError("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata3(value.taskset);
+  const id = `model-review-${contentHash([input.scope, request.modelId, request.operationId])}`;
+  const edits = new Map(request.examples.map((edit) => [contentHash(edit.evidence), edit]));
+  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef5(evidence2))));
+  const decisions = new Map(learning.decisions.map((decision) => [contentHash(decision.evidence), decision]));
+  if (edits.size !== request.examples.length || request.examples.some((edit) => !parentRefs.has(contentHash(edit.evidence)))) {
+    throw new LearningDomainError("model_review_evidence_mismatch", 409);
+  }
+  for (const resource of [input.binding, ...input.rewards, ...input.assets]) assertLearningContentHash3(resource);
+  resolveBoundRewards(input.binding, input.rewards);
+  const rewardByHash = /* @__PURE__ */ new Map();
+  for (const source2 of input.binding.sources) {
+    const original = input.rewards.find((reward) => sameLearningRef3(learningRef5(reward), source2.reward));
+    const { contentHash: _hash, ...content } = original;
+    rewardByHash.set(original.contentHash, createRewardRelease({ ...content, id: `${id}-reward-${original.contentHash}`, revision: 1 }));
+  }
+  const rewards = [...rewardByHash.values()];
+  const { contentHash: _bindingHash, recipeRef: _recipe, ...bindingContent } = input.binding;
+  const binding = createRewardBinding({
+    ...bindingContent,
+    id: `${id}-binding`,
+    revision: 1,
+    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef5(rewardByHash.get(source2.reward.contentHash)) }))
+  }, rewards);
+  const assetRefs = rewards.flatMap((reward) => [
+    ...reward.assets,
+    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
+    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]);
+  const assets = [...new Map(assetRefs.map((ref) => {
+    const asset = input.assets.find((asset2) => asset2.id === ref.id);
+    if (!asset) throw new LearningDomainError("model_review_reward_asset_missing", 422);
+    verifyLearningTextAsset5(asset, ref);
+    if (ref.visibility === "policy") throw new LearningDomainError("reward_asset_visibility_invalid", 422);
+    return [asset.id, asset];
+  })).values()];
+  const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
+  const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
+  const definition = TaskDefinitionSchema3.parse(sealLearningContent4({
+    ...definitionContent,
+    ...request.definition,
+    id: `${id}-definition`,
+    revision: 1,
+    rewardBinding: learningRef5(binding),
+    execution: {
+      ...execution,
+      policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders2(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
+    }
+  }));
+  const source = LearningSourceSchema3.parse(sealLearningContent4({
+    schemaVersion: "openpond.learningSource.v1",
+    id,
+    revision: 1,
+    name: `${definition.name} review`,
+    kind: "direct",
+    taskDefinition: learningRef5(definition),
+    enabled: true,
+    allowedSplits: [...new Set(learning.evidence.map((item) => item.submission.split))],
+    mapping: null,
+    adapterVersion: null,
+    reviewOrigin: {
+      modelId: request.modelId,
+      packageHash: value.contentHash,
+      taskset: learningRef5(value.taskset),
+      batch: learningRef5(learning.batch),
+      rewardBinding: learningRef5(input.binding)
+    }
+  }));
+  const evidence = learning.evidence.map((parent) => {
+    const edit = edits.get(contentHash(learningRef5(parent)));
+    const attemptId = `review-${parent.contentHash}`;
+    const policyChanged = contentHash({
+      instructions: definition.instructions,
+      inputSchema: definition.inputSchema,
+      outputSchema: definition.outputSchema,
+      input: edit?.input ?? parent.submission.input
+    }) !== contentHash({
+      instructions: metadata.definition.instructions,
+      inputSchema: metadata.definition.inputSchema,
+      outputSchema: metadata.definition.outputSchema,
+      input: parent.submission.input
+    });
+    return TaskEvidenceSchema3.parse(sealLearningContent4({
+      schemaVersion: "openpond.taskEvidence.v1",
+      id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
+      revision: 1,
+      source: learningRef5(source),
+      submission: {
+        ...parent.submission,
+        sourceId: source.id,
+        taskDefinition: learningRef5(definition),
+        attemptId,
+        // The old response was observed under the old policy-visible task. Its
+        // parent snapshot remains available, but it is not a run of new inputs.
+        observedOutput: policyChanged ? null : parent.submission.observedOutput,
+        idempotencyKey: `${id}-${parent.contentHash}`,
+        ...edit?.input === void 0 ? {} : { input: edit.input },
+        ...edit?.expected === void 0 ? {} : { expected: edit.expected },
+        ...edit?.evaluatorContext === void 0 ? {} : { evaluatorContext: edit.evaluatorContext }
+      },
+      supersedes: learningRef5(parent),
+      correctionFeedbackId: null,
+      receivedAt: input.now
+    }));
+  });
+  const proposals = evidence.flatMap((item) => {
+    const edit = edits.get(contentHash(item.supersedes));
+    const decision = decisions.get(contentHash(item.supersedes));
+    const target = edit?.proposedTarget === void 0 ? decision.approvedTarget : edit.proposedTarget;
+    return target === null ? [] : [TaskFeedbackSchema2.parse({
+      schemaVersion: "openpond.taskFeedbackRecord.v1",
+      id: `feedback-${contentHash([id, item.id])}`,
+      revision: 1,
+      submission: {
+        schemaVersion: "openpond.taskFeedback.v1",
+        sourceId: source.id,
+        idempotencyKey: `${id}-${item.id}`,
+        exampleId: item.submission.exampleId,
+        attemptId: item.submission.attemptId,
+        expectedEvidenceHash: item.contentHash,
+        occurredAt: input.now,
+        kind: "target_correction",
+        value: target,
+        note: "Proposed target for the revised task. Grade and review before admission."
+      },
+      status: "pending_review",
+      evidence: learningRef5(item),
+      createdAt: input.now,
+      review: null
+    })];
+  });
+  return { source, definition, binding, rewards, assets, evidence, proposals };
+}
+
+// src/model-batch-review.ts
+import { LearningDomainError as LearningDomainError3 } from "@openpond/evals/learning";
+var operation = (request) => `model-batch-review-${contentHash([request.modelId, request.operationId])}`;
+function inspectModelBatchPackage(raw) {
+  const value = validateTasksetPackage(raw);
+  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata4(value.taskset);
+  return ModelBatchReviewInspectionSchema.parse({
+    schemaVersion: "openpond.modelBatchReviewInspection.v1",
+    packageHash: value.contentHash,
+    definition: metadata.definition,
+    binding: metadata.binding,
+    evidence: value.learningResources.evidence,
+    decisions: value.learningResources.decisions
+  });
+}
+async function findModelBatchReview(transaction, raw) {
+  const request = ModelBatchReviewRequestSchema.parse(raw);
+  const prior = await transaction.operation(operation(request));
+  if (!prior) return null;
+  if (prior.requestHash !== contentHash(request)) throw new LearningDomainError2("learning_idempotency_conflict", 409);
+  return readReceipt(transaction, request, prior.resources);
+}
+async function beginModelBatchReview(transaction, input) {
+  const request = ModelBatchReviewRequestSchema.parse(input.request);
+  const prior = await findModelBatchReview(transaction, request);
+  if (prior) return prior;
+  const value = validateTasksetPackage(input.package);
+  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
+  const metadata = taskBatchPackageMetadata4(value.taskset);
+  const selected = request.rewardBindingRef;
+  const retained = !selected || sameLearningRef4(selected, learningRef6(metadata.binding));
+  const binding = retained ? metadata.binding : await requireLearningRelease(transaction, "binding", selected);
+  const rewards = retained ? metadata.rewards : await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
+  const assetIds = new Set(rewards.flatMap((reward) => [
+    ...reward.assets,
+    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
+    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
+    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
+  ]).map((asset) => asset.id));
+  const assets = retained ? value.learningResources.assets : await Promise.all([...assetIds].map((id) => requireLearningResource(transaction, "asset", id, 1)));
+  const prepared = prepareModelBatchReview({ ...input, request, package: value, binding, rewards, assets });
+  const pointers = [];
+  for (const asset of prepared.assets) {
+    const existing = await transaction.get("asset", asset.id, 1);
+    if (existing && existing.contentHash !== asset.contentHash) throw new LearningDomainError2("model_review_asset_conflict", 409);
+    if (!existing) await transaction.put("asset", asset, 0);
+  }
+  for (const reward of prepared.rewards) await transaction.put("reward", reward, 0);
+  await transaction.put("binding", prepared.binding, 0);
+  await transaction.put("definition", prepared.definition, 0);
+  await transaction.put("source", prepared.source, 0, { parentId: request.modelId });
+  pointers.push({ kind: "source", id: prepared.source.id, revision: 1 });
+  for (const evidence of prepared.evidence) {
+    await transaction.put("evidence", evidence, 0, { parentId: prepared.source.id });
+    pointers.push({ kind: "evidence", id: evidence.id, revision: 1 });
+  }
+  for (const proposal of prepared.proposals) {
+    await transaction.put("feedback", proposal, 0, { parentId: proposal.evidence.id, status: proposal.status });
+    pointers.push({ kind: "feedback", id: proposal.id, revision: 1 });
+  }
+  await transaction.saveOperation(operation(request), { requestHash: contentHash(request), resources: pointers });
+  return readReceipt(transaction, request, pointers);
+}
+async function readReceipt(transaction, request, pointers) {
+  const resources = await Promise.all(pointers.map((pointer) => requireLearningResource(transaction, pointer.kind, pointer.id, pointer.revision)));
+  return ModelBatchReviewReceiptSchema.parse({
+    schemaVersion: "openpond.modelBatchReviewReceipt.v1",
+    operationId: request.operationId,
+    modelId: request.modelId,
+    source: resources.find((resource) => resource.schemaVersion === "openpond.learningSource.v1"),
+    evidence: resources.filter((resource) => resource.schemaVersion === "openpond.taskEvidence.v1"),
+    proposals: resources.filter((resource) => resource.schemaVersion === "openpond.taskFeedbackRecord.v1")
+  });
+}
 export {
   MAX_TASKSET_PACKAGE_BYTES,
+  LearningDomainError3 as ModelBatchReviewError,
+  ModelBatchReviewInspectionSchema,
+  ModelBatchReviewReceiptSchema,
+  ModelBatchReviewRequestSchema,
   OpenPondTasksetPackageClient,
   OpenPondTasksetPackageError,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
+  TasksetPackageLearningResourcesSchema,
   TasksetPackageModelConfigurationSchema,
   TasksetPackagePublicationSchema,
   TasksetPackageReadbackSchema,
   TasksetPackageReceiptSchema,
   TasksetPackageSchema,
+  beginModelBatchReview,
   createTasksetPackage,
   decodeTasksetPackageFile,
+  findModelBatchReview,
+  inspectModelBatchPackage,
+  learningPackageContextFiles,
+  tasksetPackageRewardBinding,
+  validateTasksetLearningResources,
   validateTasksetPackage
 };
 //# sourceMappingURL=taskset-packages.js.map