openpond-sdk 0.12.13 → 0.12.15

package/dist/chunk-EBB36D5X.js

@@ -0,0 +1,866 @@
+import {
+  SftRecipeSchema
+} from "./chunk-UVQENVTW.js";
+import {
+  ModelProjectBaseModelSchema,
+  ModelProjectImmutableRefSchema,
+  ModelProjectRecipeDocumentSchema,
+  ModelProjectVersionedRefSchema,
+  TrainingGpuSelectionSchema
+} from "./chunk-MVAEE5EI.js";
+import {
+  OpenPondProtocolError,
+  TRAINING_INPUT_ARTIFACT_MAX_BYTES,
+  TRAINING_JOB_SUBMISSION_MAX_BYTES,
+  assertCanonicalPayloadSize,
+  canonicalSha256
+} from "./chunk-B3ZHJ2KK.js";
+
+// src/managed-compute-price.ts
+import { z } from "zod";
+var Hash = z.string().regex(/^[a-f0-9]{64}$/);
+var Money = z.string().regex(/^(0|[1-9]\d*)(\.\d{1,6})?$/).max(24);
+var micros = (value) => {
+  const [whole, fraction = ""] = Money.parse(value).split(".");
+  return BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"));
+};
+var ComputeAppliedPriceSchema = z.object({
+  schemaVersion: z.literal("openpond.computeAppliedPrice.v1"),
+  version: z.string().min(1).max(500),
+  service: z.enum(["managed_rl", "model_modification", "model_serving", "sandbox"]),
+  profileHash: Hash,
+  currency: z.literal("USD"),
+  unit: z.literal("resource_hour"),
+  hourlyUsd: Money.refine((value) => {
+    if (!Money.safeParse(value).success) return false;
+    const amount = micros(value);
+    return amount > 0n && amount <= BigInt(Number.MAX_SAFE_INTEGER);
+  })
+}).strict();
+var ManagedModificationPriceSchema = z.object({
+  schemaVersion: z.literal("openpond.modificationPrice.v1"),
+  appliedPrice: ComputeAppliedPriceSchema.extend({ service: z.literal("model_modification") }),
+  billingBoundary: z.literal("active_allocation_until_verified_cleanup"),
+  startupBillable: z.literal(true),
+  postCompletionIdleBillable: z.literal(false),
+  minimumBillableSeconds: z.literal(0),
+  warmReuseSeconds: z.literal(300)
+}).strict();
+function canonicalComputeSpendCap(value) {
+  if (value == null || value.trim() === "") return null;
+  const amount = micros(value);
+  if (amount <= 0n || amount > 1000000000000n)
+    throw new OpenPondProtocolError("managed_modification_cap_invalid", "Choose a positive spending limit of at most 1,000,000 USD, or use available credits.");
+  return `${amount / 1000000n}.${(amount % 1000000n).toString().padStart(6, "0")}`;
+}
+function assertManagedModificationPricing(plan) {
+  if (plan.maximumSpendUsd !== canonicalComputeSpendCap(plan.maximumSpendUsd) || plan.maximumSpendUsd === null && !plan.computePrice || plan.computePrice && plan.computePrice.appliedPrice.profileHash !== plan.runtimeHash)
+    throw new OpenPondProtocolError("managed_modification_price_mismatch", "Retain the exact reviewed rate, runtime and optional spending limit.");
+}
+async function managedModificationPriceApprovalMatches(plan, command) {
+  return plan.computePrice ? command.approvedPriceHash === await canonicalSha256(plan.computePrice) : command.approvedPriceHash === void 0;
+}
+
+// src/training-usage-funding.ts
+import { z as z2 } from "zod";
+var Id = z2.string().min(1).max(500);
+var Hash2 = z2.string().regex(/^[a-f0-9]{64}$/);
+var Price = ComputeAppliedPriceSchema.extend({ service: z2.literal("managed_rl") });
+var Cap = z2.string().regex(/^(0|[1-9]\d*)\.\d{6}$/).max(24).refine((value) => {
+  if (!/^(0|[1-9]\d*)\.\d{6}$/.test(value) || value.length > 24) return false;
+  const micros2 = BigInt(value.replace(".", ""));
+  return micros2 > 0n && micros2 <= BigInt(Number.MAX_SAFE_INTEGER);
+}).nullable();
+var Guests = z2.array(z2.object({
+  profileHash: Hash2,
+  price: Price,
+  resources: z2.object({ cpu: z2.number().positive(), memoryGb: z2.number().positive(), diskGb: z2.number().nonnegative() }).strict()
+}).strict()).max(32);
+var Rate = z2.string().regex(/^(0|[1-9]\d*)\.\d{6}$/).max(24).refine((value) => /^(0|[1-9]\d*)\.\d{6}$/.test(value) && value.length <= 24 && BigInt(value.replace(".", "")) <= BigInt(Number.MAX_SAFE_INTEGER));
+var Judges = z2.object({
+  billing: z2.literal("existing_retail_child_captures"),
+  acceptedPricingHashes: z2.array(Hash2).max(64),
+  prices: z2.array(z2.object({
+    modelId: Id,
+    displayName: Id,
+    acceptedPricingHash: Hash2,
+    inputUsdPerMillionTokens: Rate,
+    cachedInputUsdPerMillionTokens: Rate,
+    outputUsdPerMillionTokens: Rate,
+    cacheWriteUsdPerMillionTokens: Rate.nullable(),
+    cacheWriteOneHourUsdPerMillionTokens: Rate.nullable(),
+    longContextThresholdTokens: z2.number().int().positive().nullable(),
+    longContext: z2.object({
+      inputUsdPerMillionTokens: Rate,
+      cachedInputUsdPerMillionTokens: Rate,
+      outputUsdPerMillionTokens: Rate,
+      cacheWriteUsdPerMillionTokens: Rate.nullable()
+    }).strict().nullable()
+  }).strict()).max(64)
+}).strict();
+var TrainingBillingModesSchema = z2.tuple([
+  z2.object({ mode: z2.literal("prepaid_only"), availability: z2.literal("available"), reason: z2.null() }).strict(),
+  z2.object({
+    mode: z2.literal("actual_usage"),
+    availability: z2.enum(["unavailable", "requires_preparation"]),
+    reason: z2.string().min(1).max(500).nullable()
+  }).strict()
+]);
+var TrainingUsageFundingRequestSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingUsageFundingRequest.v1"),
+  billingMode: z2.literal("actual_usage"),
+  customerCapUsd: Cap
+}).strict();
+var TrainingUsageQuoteContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.trainingUsageQuote.v1"),
+  teamId: Id,
+  actorUserId: Id,
+  preparationId: Id,
+  submissionHash: Hash2,
+  workerImageDigest: z2.string().regex(/^sha256:[a-f0-9]{64}$/),
+  customerCapUsd: Cap,
+  maximumWallSeconds: z2.number().int().positive(),
+  retentionDays: z2.number().int().nonnegative(),
+  gpu: Price,
+  guests: Guests,
+  judges: Judges,
+  storage: z2.object({
+    price: Price,
+    storageClass: z2.literal("STANDARD"),
+    quantityBasis: z2.literal("gib_milliseconds"),
+    onCreditExhaustion: z2.literal("retain_objects_and_stop_new_storage")
+  }).strict(),
+  gpuBillingBoundary: z2.literal("active_allocation_until_verified_cleanup"),
+  storageBillingBoundary: z2.literal("accepted_retention_window"),
+  startupBillable: z2.literal(true),
+  postCompletionIdleBillable: z2.literal(false),
+  minimumBillableSeconds: z2.literal(0),
+  issuedAt: z2.iso.datetime(),
+  expiresAt: z2.iso.datetime()
+}).strict();
+var TrainingUsageQuoteSchema = TrainingUsageQuoteContentSchema.extend({ contentHash: Hash2, signature: Id }).strict();
+async function verifyTrainingUsageQuote(raw, expected) {
+  const quote = TrainingUsageQuoteSchema.parse(raw), { contentHash, signature: _signature, ...content } = quote;
+  if (contentHash !== await canonicalSha256(content) || quote.teamId !== expected.teamId || quote.actorUserId !== expected.actorUserId || quote.preparationId !== expected.preparationId || quote.submissionHash !== expected.submissionHash || quote.customerCapUsd !== expected.customerCapUsd || Date.parse(quote.expiresAt) <= Date.parse(quote.issuedAt) || new Set(quote.guests.map((guest) => guest.profileHash)).size !== quote.guests.length || quote.guests.some((guest) => guest.profileHash !== guest.price.profileHash) || new Set(quote.judges.acceptedPricingHashes).size !== quote.judges.acceptedPricingHashes.length || new Set(quote.judges.prices.map((price) => price.acceptedPricingHash)).size !== quote.judges.prices.length || quote.judges.prices.length !== quote.judges.acceptedPricingHashes.length || quote.judges.prices.some((price) => !quote.judges.acceptedPricingHashes.includes(price.acceptedPricingHash)))
+    throw new OpenPondProtocolError("training_usage_quote_mismatch", "Training prices differ from the reviewed preparation, actor or spending limit.");
+  return quote;
+}
+
+// src/training-recovery.ts
+import { z as z3 } from "zod";
+var id = z3.string().trim().min(1).max(191);
+var hash = z3.string().regex(/^[a-f0-9]{64}$/);
+var ApprovalBodySchema = z3.object({
+  schemaVersion: z3.literal("openpond.checkpointRecoveryResourceApproval.v1"),
+  ownerUserId: id,
+  teamId: id,
+  sourceJobId: id,
+  sourceJobVersion: z3.number().int().positive(),
+  sourceInputManifestSha256: hash,
+  checkpointId: id,
+  adapterSha256: hash,
+  resumeSha256: hash,
+  idempotencyKey: z3.string().trim().min(16).max(191),
+  approvedAt: z3.iso.datetime({ offset: true }),
+  maximumSpendUsd: z3.number().positive().finite().max(30).refine(
+    (value) => Number(value.toFixed(6)) === value,
+    "Recovery spend must use whole microdollars"
+  ),
+  maximumGpuSeconds: z3.number().int().positive().max(21600),
+  maximumWallSeconds: z3.number().int().positive().max(21600)
+}).strict();
+var TrainingCheckpointRecoveryResourceApprovalSchema = ApprovalBodySchema.extend({
+  approvalHash: hash
+}).strict().superRefine((value, context) => {
+  if (value.maximumGpuSeconds > value.maximumWallSeconds)
+    context.addIssue({
+      code: "custom",
+      path: ["maximumGpuSeconds"],
+      message: "Recovery GPU duration exceeds its wall"
+    });
+});
+async function createTrainingCheckpointRecoveryResourceApproval(input) {
+  const body = ApprovalBodySchema.parse(input);
+  return TrainingCheckpointRecoveryResourceApprovalSchema.parse({
+    ...body,
+    approvalHash: await canonicalSha256(body)
+  });
+}
+var TrainingCheckpointRecoveryRequestSchema = z3.object({
+  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
+  mode: z3.literal("evaluation_only").optional(),
+  evaluationGpuType: z3.enum(["NVIDIA A100 80GB PCIe", "NVIDIA A100-SXM4-80GB", "NVIDIA H100 80GB HBM3"]).optional(),
+  expectedVersion: z3.number().int().positive(),
+  checkpointId: id,
+  idempotencyKey: z3.string().trim().min(16).max(191),
+  maximumSpendUsd: z3.number().positive().finite(),
+  maximumWallSeconds: z3.number().int().positive().max(21600)
+}).strict().superRefine((value, context) => {
+  if (value.evaluationGpuType && value.mode !== "evaluation_only")
+    context.addIssue({
+      code: "custom",
+      path: ["evaluationGpuType"],
+      message: "GPU substitution requires explicit evaluation-only recovery"
+    });
+  const a = value.resourceApproval;
+  if (a && (a.sourceJobVersion !== value.expectedVersion || a.checkpointId !== value.checkpointId || a.idempotencyKey !== value.idempotencyKey || a.maximumSpendUsd !== value.maximumSpendUsd || a.maximumWallSeconds !== value.maximumWallSeconds))
+    context.addIssue({
+      code: "custom",
+      path: ["resourceApproval"],
+      message: "Recovery resource approval does not match its request"
+    });
+});
+
+// src/training-physical-placement.ts
+import { z as z4 } from "zod";
+var TrainingPhysicalPlacementSchema = z4.object({
+  mode: z4.literal("reuse_only"),
+  physicalWorkerId: z4.string().trim().min(1).max(191),
+  providerPodId: z4.string().trim().min(1).max(191),
+  workerImageDigest: z4.string().regex(/^sha256:[a-f0-9]{64}$/),
+  baseProfileSha256: z4.string().regex(/^[a-f0-9]{64}$/),
+  gpuType: z4.string().trim().min(1).max(200),
+  sourceJobId: z4.string().trim().min(1).max(191),
+  sourceInputManifestSha256: z4.string().regex(/^[a-f0-9]{64}$/),
+  ownerTeamId: z4.string().trim().min(1).max(191),
+  deadlineAt: z4.string().datetime({ offset: true })
+}).strict();
+
+// src/training-queue.ts
+import { z as z5 } from "zod";
+var Timestamp = z5.string().datetime({ offset: true });
+var TrainingQueueStatusSchema = z5.object({
+  ticketId: z5.string().trim().min(1).max(191),
+  ticketNumber: z5.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  label: z5.literal("Waiting for resources"),
+  position: z5.number().int().positive().nullable(),
+  positionScope: z5.literal("compatible_fair_queue"),
+  enqueuedAt: Timestamp,
+  asOf: Timestamp,
+  estimate: z5.object({
+    revision: z5.number().int().nonnegative(),
+    estimatedStartAt: Timestamp,
+    expiresAt: Timestamp,
+    evidence: z5.enum(["observed_capacity", "measured_bootstrap", "scheduled_release"])
+  }).strict().nullable()
+}).strict().superRefine((value, context) => {
+  if (value.estimate && Date.parse(value.estimate.expiresAt) <= Date.parse(value.asOf))
+    context.addIssue({ code: "custom", path: ["estimate"], message: "An expired queue forecast must be returned as unavailable" });
+});
+
+// src/training-usage-status.ts
+import { z as z6 } from "zod";
+var Money2 = z6.string().regex(/^(0|[1-9]\d*)\.\d{6}$/).max(24).refine((value) => /^(0|[1-9]\d*)\.\d{6}$/.test(value) && value.length <= 24 && BigInt(value.replace(".", "")) <= BigInt(Number.MAX_SAFE_INTEGER));
+var TrainingUsageSnapshotSchema = z6.object({
+  schemaVersion: z6.literal("openpond.trainingUsageSnapshot.v1"),
+  asOf: z6.iso.datetime(),
+  customerCapUsd: Money2.nullable(),
+  chargedUsd: Money2,
+  committedUsd: Money2,
+  outstandingUsd: Money2,
+  remainingCapUsd: Money2.nullable(),
+  availableCreditUsd: Money2,
+  complete: z6.boolean(),
+  components: z6.array(z6.object({
+    component: z6.enum(["gpu", "guest", "storage", "judge"]),
+    chargedUsd: Money2,
+    committedUsd: Money2,
+    outstandingUsd: Money2,
+    openOwners: z6.number().int().nonnegative()
+  }).strict()).length(4).refine((values) => values.every((value, index) => value.component === ["gpu", "guest", "storage", "judge"][index]))
+}).strict();
+
+// src/training-job-contracts.ts
+import { z as z7 } from "zod";
+import { TrainingHandoffOriginSchema } from "@openpond/evals/learning";
+var IdSchema = z7.string().trim().min(1).max(500);
+var HashSchema = z7.string().regex(/^[a-f0-9]{64}$/);
+var TimestampSchema = z7.string().datetime({ offset: true });
+var TrainingInputArtifactUploadSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingInputArtifactUpload.v2"),
+  kind: z7.enum(["portable_training_bundle", "reward_model_dataset"]),
+  idempotencyKey: z7.string().trim().min(1).max(500),
+  sourceManifest: ModelProjectImmutableRefSchema,
+  payload: z7.unknown(),
+  contentHash: HashSchema
+}).strict();
+var TrainingInputArtifactSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingInputArtifact.v2"),
+  kind: z7.enum(["portable_training_bundle", "reward_model_dataset"]),
+  sourceManifest: ModelProjectImmutableRefSchema,
+  artifactRef: z7.string().trim().min(1).max(2e3),
+  contentHash: HashSchema,
+  sizeBytes: z7.number().int().positive(),
+  createdAt: TimestampSchema
+}).strict();
+async function trainingInputArtifactUploadHash(upload) {
+  const { contentHash: _contentHash, ...content } = upload;
+  return canonicalSha256(content);
+}
+async function parseAndVerifyTrainingInputArtifactUpload(value) {
+  assertCanonicalPayloadSize(value, TRAINING_INPUT_ARTIFACT_MAX_BYTES, "Training input artifact");
+  const parsed = TrainingInputArtifactUploadSchema.parse(value);
+  const expectedHash = await trainingInputArtifactUploadHash(parsed);
+  if (parsed.contentHash !== expectedHash) {
+    throw new OpenPondProtocolError(
+      "content_hash_mismatch",
+      `Training input artifact contentHash ${parsed.contentHash} does not match ${expectedHash}.`
+    );
+  }
+  return parsed;
+}
+var TrainingJobKindSchema = z7.enum(["reward_model_train", "policy_optimize"]);
+var TrainingJobStateSchema = z7.enum([
+  "queued",
+  "admitting",
+  "provisioning",
+  "running",
+  "stopping",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled"
+]);
+var TrainingCapabilityRequirementSchema = z7.object({
+  id: IdSchema,
+  version: z7.string().trim().min(1).max(200).nullable().default(null),
+  required: z7.boolean().default(true)
+}).strict();
+var TrainingJobSourceSchema = z7.object({
+  origin: TrainingHandoffOriginSchema.optional(),
+  modelProject: z7.object({
+    id: IdSchema,
+    portableProjectId: IdSchema,
+    revision: z7.number().int().positive(),
+    contentHash: HashSchema
+  }).strict(),
+  harnessRunManifest: ModelProjectImmutableRefSchema,
+  harnessRelease: ModelProjectImmutableRefSchema,
+  taskset: ModelProjectVersionedRefSchema,
+  tasksetRelease: ModelProjectImmutableRefSchema,
+  evaluation: z7.object({
+    taskset: ModelProjectVersionedRefSchema,
+    dataset: ModelProjectImmutableRefSchema
+  }).strict().nullable().optional(),
+  dataset: ModelProjectImmutableRefSchema,
+  evidenceSets: z7.array(ModelProjectImmutableRefSchema).max(1e4)
+}).strict();
+var RewardModelTrainingRequestSchema = z7.object({
+  kind: z7.literal("reward_model_train"),
+  baseModel: ModelProjectBaseModelSchema,
+  preferenceDatasetRelease: ModelProjectImmutableRefSchema,
+  processorRelease: ModelProjectImmutableRefSchema,
+  recipe: z7.object({
+    schemaVersion: z7.literal("openpond.rewardModelRecipe.v1"),
+    method: z7.literal("reward_model"),
+    parameterization: z7.literal("lora_with_scalar_head")
+  }).catchall(z7.unknown())
+}).strict();
+var DeterministicRewardSourceSchema = z7.object({
+  kind: z7.literal("deterministic"),
+  grader: ModelProjectImmutableRefSchema,
+  composer: ModelProjectImmutableRefSchema.nullable().default(null)
+}).strict();
+var LearnedRewardSourceSchema = z7.object({
+  kind: z7.literal("learned_reward"),
+  rewardModelVersion: ModelProjectImmutableRefSchema,
+  qualificationReport: ModelProjectImmutableRefSchema.nullable().default(null),
+  evaluationReferences: z7.array(ModelProjectImmutableRefSchema).max(1e3).default([]),
+  scorerArtifact: z7.object({
+    artifactRef: z7.string().trim().min(1).max(2e3),
+    contentHash: HashSchema,
+    executionReceipt: ModelProjectImmutableRefSchema
+  }).strict(),
+  processorRelease: ModelProjectImmutableRefSchema,
+  rewardComposerRelease: ModelProjectImmutableRefSchema
+}).strict();
+var TrainingQualificationBaseModelSchema = ModelProjectBaseModelSchema.extend({
+  revision: z7.string().regex(/^[a-f0-9]{40,64}$/),
+  tokenizerRevision: z7.string().regex(/^[a-f0-9]{40,64}$/),
+  chatTemplateHash: HashSchema
+}).strict();
+var PolicyOptimizationRequestSchema = z7.object({
+  kind: z7.literal("policy_optimize"),
+  /** Collect and grade one original-learner group without optimizer work. */
+  executionMode: z7.literal("qualification").optional(),
+  baseModel: ModelProjectBaseModelSchema,
+  recipe: ModelProjectRecipeDocumentSchema,
+  rewardSource: z7.discriminatedUnion("kind", [
+    DeterministicRewardSourceSchema,
+    LearnedRewardSourceSchema
+  ]),
+  resumeFrom: ModelProjectImmutableRefSchema.nullable().default(null)
+}).strict().superRefine((job, context) => {
+  if (job.recipe.method !== "sft") return;
+  const recipe = SftRecipeSchema.safeParse(job.recipe);
+  if (!recipe.success) {
+    context.addIssue({
+      code: "custom",
+      path: ["recipe"],
+      message: "The SFT recipe is incomplete or invalid."
+    });
+    return;
+  }
+  if (job.executionMode || job.resumeFrom || "continuation" in job.recipe)
+    context.addIssue({
+      code: "custom",
+      message: "Initial managed SFT requires a fresh supervised run without rollout qualification or continuation."
+    });
+  if (recipe.data.baseModel.id !== job.baseModel.modelId || recipe.data.baseModel.revision !== job.baseModel.revision || recipe.data.baseModel.tokenizerRevision !== job.baseModel.tokenizerRevision || recipe.data.baseModel.chatTemplateHash !== job.baseModel.chatTemplateHash)
+    context.addIssue({
+      code: "custom",
+      path: ["baseModel"],
+      message: "The SFT recipe must pin the exact submitted base and tokenizer."
+    });
+});
+var TrainingJobRequestSchema = z7.discriminatedUnion("kind", [
+  RewardModelTrainingRequestSchema,
+  PolicyOptimizationRequestSchema
+]);
+var TrainingJobApprovalSchema = z7.object({
+  approvalHash: HashSchema,
+  approvedAt: TimestampSchema,
+  exportApproved: z7.boolean(),
+  maximumSpendUsd: z7.number().nonnegative(),
+  retentionDays: z7.number().int().nonnegative().nullable(),
+  region: z7.string().trim().min(1).max(200).nullable().default(null)
+}).strict();
+var TrainingJobSubmissionSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJobSubmission.v2"),
+  idempotencyKey: z7.string().trim().min(1).max(500),
+  name: z7.string().trim().min(1).max(200),
+  source: TrainingJobSourceSchema,
+  job: TrainingJobRequestSchema,
+  requestedCapabilities: z7.array(TrainingCapabilityRequirementSchema).max(1e3),
+  placementObjective: z7.enum(["fast", "balanced", "economical"]),
+  gpuSelection: TrainingGpuSelectionSchema.optional(),
+  physicalPlacement: TrainingPhysicalPlacementSchema.optional(),
+  budget: z7.object({
+    maximumSpendUsd: z7.number().nonnegative(),
+    maximumWallSeconds: z7.number().int().positive()
+  }).strict(),
+  approval: TrainingJobApprovalSchema,
+  contentHash: HashSchema
+}).strict().superRefine((submission, context) => {
+  const distributed = (submission.gpuSelection?.gpuCount ?? 1) === 2;
+  const distributedRequirement = submission.requestedCapabilities.some((requirement) => requirement.id === "managed_rl.policy.data_parallel" && requirement.version === "1" && requirement.required);
+  if (distributed !== distributedRequirement) {
+    context.addIssue({ code: "custom", path: ["requestedCapabilities"], message: "Two-GPU training must require managed_rl.policy.data_parallel@1 and bind gpuSelection.gpuCount to 2." });
+  }
+  if (distributed && (submission.job.kind !== "policy_optimize" || submission.job.executionMode || submission.job.recipe.method !== "grpo" || submission.physicalPlacement)) {
+    context.addIssue({ code: "custom", path: ["gpuSelection"], message: "Two-GPU execution requires exclusive GRPO policy training." });
+  }
+  if (submission.physicalPlacement && (submission.job.kind !== "policy_optimize" || submission.job.resumeFrom || submission.job.executionMode || submission.job.recipe.continuation !== void 0)) {
+    context.addIssue({ code: "custom", path: ["physicalPlacement"], message: "Reuse-only placement requires fresh-base policy training without continuation." });
+  }
+  if (submission.job.kind === "policy_optimize" && submission.job.executionMode === "qualification") {
+    const job = submission.job;
+    if (!TrainingQualificationBaseModelSchema.safeParse(job.baseModel).success) {
+      context.addIssue({ code: "custom", path: ["job", "baseModel"], message: "Qualification requires immutable model and tokenizer revisions and a SHA-256 chat-template pin." });
+    }
+    if (job.resumeFrom || job.recipe.continuation !== void 0 || job.rewardSource.kind !== "deterministic" || job.recipe.method !== "grpo") {
+      context.addIssue({
+        code: "custom",
+        path: ["job"],
+        message: "Qualification requires the original GRPO learner, deterministic reward, and no resume or continuation."
+      });
+    }
+    if (!submission.requestedCapabilities.some((requirement) => requirement.required && requirement.id === "managed_rl.policy.qualification" && requirement.version === "1")) {
+      context.addIssue({
+        code: "custom",
+        path: ["requestedCapabilities"],
+        message: "Qualification must require managed_rl.policy.qualification@1."
+      });
+    }
+  }
+  if (submission.approval.maximumSpendUsd !== submission.budget.maximumSpendUsd) {
+    context.addIssue({
+      code: "custom",
+      path: ["approval", "maximumSpendUsd"],
+      message: "Approved spend must equal the immutable Job budget."
+    });
+  }
+});
+async function trainingJobSubmissionHash(submission) {
+  const { contentHash: _contentHash, ...content } = submission;
+  return canonicalSha256(content);
+}
+async function parseAndVerifyTrainingJobSubmission(value) {
+  assertCanonicalPayloadSize(value, TRAINING_JOB_SUBMISSION_MAX_BYTES, "Training Job submission");
+  const parsed = TrainingJobSubmissionSchema.parse(value);
+  const expectedHash = await trainingJobSubmissionHash(parsed);
+  if (parsed.contentHash !== expectedHash) {
+    throw new OpenPondProtocolError(
+      "content_hash_mismatch",
+      `Training Job contentHash ${parsed.contentHash} does not match ${expectedHash}.`
+    );
+  }
+  return parsed;
+}
+var TrainingJobRecoverySchema = z7.object({
+  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
+  mode: z7.literal("evaluation_only").optional(),
+  trainingWorkloadComplete: z7.boolean().optional(),
+  sourceJobId: IdSchema,
+  checkpointId: IdSchema,
+  policyVersion: z7.number().int().positive(),
+  completedGroups: z7.number().int().positive(),
+  optimizerMode: z7.literal("continue")
+}).strict();
+var TrainingJobSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJob.v2"),
+  id: IdSchema,
+  teamId: IdSchema,
+  kind: TrainingJobKindSchema,
+  executionMode: z7.literal("qualification").optional(),
+  recovery: TrainingJobRecoverySchema.optional(),
+  modelProjectId: IdSchema,
+  portableProjectId: IdSchema,
+  sourceProjectRevision: z7.number().int().positive(),
+  submissionHash: HashSchema,
+  state: TrainingJobStateSchema,
+  queue: TrainingQueueStatusSchema.optional(),
+  phase: z7.string().trim().min(1).max(200),
+  version: z7.number().int().nonnegative(),
+  progress: z7.number().min(0).max(1),
+  rolloutProgress: z7.object({
+    groupsCompleted: z7.number().int().nonnegative(),
+    groupsTarget: z7.number().int().nonnegative(),
+    optimizerUpdatesApplied: z7.number().int().nonnegative(),
+    optimizerUpdatesSkipped: z7.number().int().nonnegative()
+  }).strict(),
+  accruedSpendUsd: z7.number().nonnegative(),
+  usage: TrainingUsageSnapshotSchema.optional(),
+  terminalReason: z7.string().trim().min(1).max(5e3).nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  completedAt: TimestampSchema.nullable()
+}).strict();
+var TrainingJobPageSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJobPage.v2"),
+  jobs: z7.array(TrainingJobSchema).max(1e3),
+  nextCursor: z7.string().trim().min(1).max(2e3).nullable()
+}).strict();
+var TrainingJobEventSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJobEvent.v2"),
+  id: IdSchema,
+  jobId: IdSchema,
+  sequence: z7.number().int().nonnegative(),
+  type: IdSchema,
+  phase: z7.string().trim().min(1).max(200),
+  message: z7.string().trim().min(1).max(5e3).nullable(),
+  data: z7.record(z7.string(), z7.unknown()).default({}),
+  createdAt: TimestampSchema
+}).strict();
+var TrainingJobLogSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJobLog.v2"),
+  jobId: IdSchema,
+  sequence: z7.number().int().nonnegative(),
+  level: z7.enum(["debug", "info", "warning", "error"]),
+  message: z7.string().max(2e4),
+  createdAt: TimestampSchema
+}).strict();
+var TrainingJobControlRequestSchema = z7.object({ expectedVersion: z7.number().int().nonnegative() }).strict();
+var TrainingJobOutputSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJobOutput.v2"),
+  id: IdSchema,
+  jobId: IdSchema,
+  kind: z7.enum(["checkpoint", "adapter", "scorer", "metrics", "evaluation", "trace", "receipt"]),
+  artifactRef: z7.string().trim().min(1).max(2e3),
+  contentHash: HashSchema,
+  sizeBytes: z7.number().int().nonnegative(),
+  metadata: z7.record(z7.string(), z7.unknown()).default({}),
+  createdAt: TimestampSchema
+}).strict();
+var TrainingQualificationEvidenceSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingQualificationEvidence.v1"),
+  baseModel: TrainingQualificationBaseModelSchema,
+  group: ModelProjectImmutableRefSchema,
+  rolloutReceipts: z7.array(ModelProjectImmutableRefSchema).min(1).max(1e3),
+  rewardEvidenceHash: HashSchema,
+  groupsCompleted: z7.literal(1),
+  optimizerUpdatesApplied: z7.literal(0),
+  optimizerUpdatesSkipped: z7.literal(0),
+  trainingStepsCreated: z7.literal(0),
+  checkpointsCreated: z7.literal(0),
+  artifactsCreated: z7.literal(0)
+}).strict().superRefine((evidence, context) => {
+  if (new Set(evidence.rolloutReceipts.map((receipt) => receipt.id)).size !== evidence.rolloutReceipts.length) {
+    context.addIssue({ code: "custom", path: ["rolloutReceipts"], message: "Qualification rollout receipt identities must be unique." });
+  }
+});
+var TrainingExecutionReceiptSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingExecutionReceipt.v2"),
+  id: IdSchema,
+  teamId: IdSchema,
+  jobId: IdSchema,
+  submissionHash: HashSchema,
+  manifestHash: HashSchema,
+  recipeHash: HashSchema,
+  capabilityHash: HashSchema,
+  runtimeRelease: ModelProjectImmutableRefSchema,
+  inputs: z7.array(ModelProjectImmutableRefSchema).max(1e4),
+  outputs: z7.array(ModelProjectImmutableRefSchema).max(1e4),
+  spendUsd: z7.number().nonnegative(),
+  durationSeconds: z7.number().nonnegative(),
+  cleanupComplete: z7.boolean(),
+  qualification: TrainingQualificationEvidenceSchema.optional(),
+  issuer: IdSchema,
+  issuedAt: TimestampSchema,
+  signature: z7.string().trim().min(1).max(1e4).nullable()
+}).strict();
+async function trainingExecutionReceiptHash(receipt) {
+  return canonicalSha256(TrainingExecutionReceiptSchema.parse(receipt));
+}
+async function parseAndVerifyTrainingExecutionReceipt(value, expected) {
+  const receipt = TrainingExecutionReceiptSchema.parse(value);
+  const expectedId = IdSchema.parse(expected.id);
+  const expectedHash = HashSchema.parse(expected.contentHash);
+  const actualHash = await trainingExecutionReceiptHash(receipt);
+  if (receipt.id !== expectedId || actualHash !== expectedHash) {
+    throw new OpenPondProtocolError(
+      "execution_receipt_mismatch",
+      "The execution receipt identity or canonical content hash did not match."
+    );
+  }
+  if (expected.teamId !== void 0 && receipt.teamId !== IdSchema.parse(expected.teamId)) {
+    throw new OpenPondProtocolError(
+      "execution_receipt_team_mismatch",
+      "The execution receipt belongs to a different team."
+    );
+  }
+  if (expected.jobId !== void 0 && receipt.jobId !== IdSchema.parse(expected.jobId)) {
+    throw new OpenPondProtocolError(
+      "execution_receipt_job_mismatch",
+      "The execution receipt belongs to a different Training Job."
+    );
+  }
+  if ((expected.requireCleanup ?? true) && !receipt.cleanupComplete) {
+    throw new OpenPondProtocolError(
+      "execution_cleanup_incomplete",
+      "The execution receipt does not attest complete terminal cleanup."
+    );
+  }
+  if (expected.qualificationSubmission) {
+    const submission = await parseAndVerifyTrainingJobSubmission(expected.qualificationSubmission);
+    if (submission.job.kind !== "policy_optimize" || submission.job.executionMode !== "qualification") {
+      throw new OpenPondProtocolError("qualification_submission_required", "Expected an immutable qualification submission.");
+    }
+    await assertTrainingQualificationReceipt(receipt, { submissionHash: submission.contentHash, baseModel: submission.job.baseModel, outputs: expected.outputs });
+  }
+  return receipt;
+}
+async function assertTrainingQualificationReceipt(receipt, expected) {
+  const evidence = TrainingQualificationEvidenceSchema.parse(receipt.qualification);
+  if (receipt.submissionHash !== expected.submissionHash || !receipt.cleanupComplete) {
+    throw new OpenPondProtocolError("qualification_receipt_mismatch", "Qualification must attest the expected submission and complete cleanup.");
+  }
+  if (expected.baseModel && await canonicalSha256(evidence.baseModel) !== await canonicalSha256(expected.baseModel)) {
+    throw new OpenPondProtocolError("qualification_learner_mismatch", "Qualification used a different original learner or tokenizer.");
+  }
+  if (expected.outputs?.some((output) => ["checkpoint", "adapter", "scorer"].includes(output.kind))) {
+    throw new OpenPondProtocolError("qualification_updated_artifact", "Qualification must not publish trained artifacts or checkpoints.");
+  }
+}
+var TrainingJobOutputsSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingJobOutputs.v2"),
+  outputs: z7.array(TrainingJobOutputSchema).max(1e4),
+  receipt: TrainingExecutionReceiptSchema.nullable()
+}).strict();
+var TrainingPolicyLoraCapabilitiesSchema = z7.object({
+  workerImageDigest: z7.string().regex(/^sha256:[a-f0-9]{64}$/),
+  envelopeRank: z7.number().int().positive().max(256),
+  supportedRanks: z7.array(z7.number().int().positive().max(256)).max(256),
+  qualification: z7.object({ evidenceRef: z7.string().min(1), evidenceSha256: HashSchema }).strict().nullable(),
+  continuation: z7.object({
+    sharedRequiresSameRank: z7.literal(true),
+    mergedRequiresSameRank: z7.literal(true),
+    residualAppendRequiresFreeCapacity: z7.literal(true),
+    stageOptimizer: z7.literal("reset"),
+    interruptedRecoveryOptimizer: z7.literal("restore")
+  }).strict()
+}).strict().superRefine((value, context) => {
+  if (new Set(value.supportedRanks).size !== value.supportedRanks.length || value.supportedRanks.some((rank) => rank > value.envelopeRank))
+    context.addIssue({ code: "custom", path: ["supportedRanks"], message: "Supported ranks must be unique and fit the physical adapter envelope." });
+  if (value.supportedRanks.length && !value.qualification)
+    context.addIssue({ code: "custom", path: ["qualification"], message: "Advertised ranks require immutable image qualification evidence." });
+});
+function supportsTrainingPolicyLoraRank(capabilities, rank, continuation) {
+  if (!capabilities.supportedRanks.includes(rank)) return false;
+  if (!continuation) return true;
+  return continuation.mode === "residual_append" ? continuation.parentEnabledRank + rank <= capabilities.envelopeRank : continuation.parentEnabledRank === rank;
+}
+var TrainingCapabilitiesSchema = z7.object({
+  schemaVersion: z7.literal("openpond.trainingCapabilities.v2"),
+  capabilityHash: HashSchema,
+  jobKinds: z7.array(TrainingJobKindSchema),
+  methods: z7.array(z7.string().trim().min(1).max(200)),
+  billingModes: TrainingBillingModesSchema.optional(),
+  executionModes: z7.array(z7.enum(["training", "qualification"])).optional(),
+  policyLora: TrainingPolicyLoraCapabilitiesSchema.optional(),
+  policyDataParallel: z7.object({
+    capability: z7.literal("managed_rl.policy.data_parallel"),
+    version: z7.literal("1"),
+    gpuCount: z7.literal(2),
+    worldSize: z7.literal(2),
+    backend: z7.literal("nccl"),
+    allocationMode: z7.literal("exclusive"),
+    workerImageDigest: z7.string().regex(/^sha256:[a-f0-9]{64}$/)
+  }).strict().optional(),
+  structuredOutputs: z7.object({
+    capability: z7.literal("work.structured-output.v1"),
+    harnessRuntimeHash: HashSchema,
+    workHarnessHash: HashSchema,
+    schemaHash: HashSchema,
+    artifactHash: HashSchema,
+    invalidDataRejected: z7.literal(true),
+    invalidBytesRejected: z7.literal(true)
+  }).strict().optional(),
+  placements: z7.array(z7.enum(["local", "remote", "colocated", "provider_native"])),
+  controls: z7.object({
+    cancel: z7.boolean(),
+    stopAfterGroup: z7.boolean(),
+    resumeFromCheckpoint: z7.boolean()
+  }).strict(),
+  estimates: z7.object({ schemaVersion: z7.literal("openpond.trainingEstimate.v1") }).strict().optional(),
+  limits: z7.object({
+    maximumSpendUsd: z7.number().nonnegative(),
+    maximumWallSeconds: z7.number().int().positive(),
+    maximumArtifactBytes: z7.number().int().positive()
+  }).strict(),
+  checkedAt: TimestampSchema,
+  expiresAt: TimestampSchema
+}).strict();
+
+// src/training-grading-plan.ts
+import { z as z8 } from "zod";
+import { compileBoundGraders, RewardBindingSchema, RewardReleaseSchema } from "@openpond/evals/rewards";
+var GradersSchema = z8.array(z8.object({ id: z8.string().trim().min(1) }).catchall(z8.unknown())).min(1).max(1e3);
+var RewardExecutionSchema = z8.object({
+  binding: RewardBindingSchema,
+  rewards: z8.array(RewardReleaseSchema).min(1).max(100)
+}).strict();
+async function deterministicTrainingRewardSource(input) {
+  const execution = input.rewardExecution ? RewardExecutionSchema.parse(input.rewardExecution) : null;
+  const graders = GradersSchema.parse(execution ? compileBoundGraders(execution.binding, execution.rewards) : input.graders);
+  if (new Set(graders.map((grader) => grader.id)).size !== graders.length) {
+    throw new Error("Training grader identities must be unique.");
+  }
+  const hash2 = await canonicalSha256({ schemaVersion: "openpond.trainingGraderSet.v1", graders });
+  return {
+    kind: "deterministic",
+    grader: { id: `training-graders-${hash2.slice(0, 32)}`, contentHash: hash2 },
+    composer: execution ? { id: execution.binding.id, contentHash: execution.binding.contentHash } : null
+  };
+}
+
+// src/training-evaluation-source.ts
+import { z as z9 } from "zod";
+var TRAINING_EVALUATION_SOURCE_PATH = "evaluation-source.json";
+var TaskIdentitySchema = z9.object({
+  id: z9.string().trim().min(1),
+  clusterKey: z9.string().trim().min(1),
+  split: z9.enum(["train", "validation", "frozen_eval"])
+}).passthrough();
+var TrainingEvaluationSourceSchema = z9.object({
+  schemaVersion: z9.literal("openpond.trainingEvaluationSource.v1"),
+  taskset: ModelProjectVersionedRefSchema,
+  tasks: z9.array(TaskIdentitySchema).min(1).max(1e4),
+  assets: z9.array(z9.object({
+    path: z9.string().trim().min(1).max(2e3),
+    sha256: z9.string().regex(/^[a-f0-9]{64}$/),
+    sizeBytes: z9.number().int().nonnegative(),
+    encoding: z9.literal("base64"),
+    content: z9.string().max(32 * 1024 * 1024)
+  }).strict()).max(1e4)
+}).strict().superRefine((source, context) => {
+  const ids = /* @__PURE__ */ new Set();
+  source.tasks.forEach((task, index) => {
+    if (task.split === "train") context.addIssue({ code: "custom", path: ["tasks", index, "split"], message: "Evaluation sources require held-out tasks." });
+    if (ids.has(task.id)) context.addIssue({ code: "custom", path: ["tasks", index, "id"], message: "Evaluation task identities must be unique." });
+    ids.add(task.id);
+  });
+});
+function assertTrainingEvaluationIsolation(trainingTasks, evaluationTasks) {
+  const training = z9.array(TaskIdentitySchema).min(1).max(1e4).parse(trainingTasks);
+  const evaluation = z9.array(TaskIdentitySchema).min(1).max(1e4).parse(evaluationTasks);
+  const trainIds = /* @__PURE__ */ new Set();
+  const trainFamilies = /* @__PURE__ */ new Set();
+  for (const task of training) {
+    if (task.split !== "train") throw new Error("The training population contains a held-out task.");
+    if (trainIds.has(task.id)) throw new Error("Training task identities must be unique.");
+    trainIds.add(task.id);
+    trainFamilies.add(task.clusterKey);
+  }
+  const evaluationIds = /* @__PURE__ */ new Set();
+  for (const task of evaluation) {
+    if (task.split === "train") throw new Error("The evaluation population contains a training task.");
+    if (evaluationIds.has(task.id)) throw new Error("Evaluation task identities must be unique.");
+    if (trainIds.has(task.id) || trainFamilies.has(task.clusterKey)) {
+      throw new Error("Training and evaluation tasks or families overlap.");
+    }
+    evaluationIds.add(task.id);
+  }
+}
+async function trainingEvaluationSourceRef(input) {
+  const source = TrainingEvaluationSourceSchema.parse(input);
+  const hash2 = await canonicalSha256(source);
+  return { taskset: source.taskset, dataset: { id: `training-evaluation-${hash2.slice(0, 32)}`, contentHash: hash2 } };
+}
+
+export {
+  ComputeAppliedPriceSchema,
+  ManagedModificationPriceSchema,
+  canonicalComputeSpendCap,
+  assertManagedModificationPricing,
+  managedModificationPriceApprovalMatches,
+  TrainingBillingModesSchema,
+  TrainingUsageFundingRequestSchema,
+  TrainingUsageQuoteContentSchema,
+  TrainingUsageQuoteSchema,
+  verifyTrainingUsageQuote,
+  TrainingCheckpointRecoveryResourceApprovalSchema,
+  createTrainingCheckpointRecoveryResourceApproval,
+  TrainingCheckpointRecoveryRequestSchema,
+  TrainingPhysicalPlacementSchema,
+  TrainingQueueStatusSchema,
+  TrainingUsageSnapshotSchema,
+  TrainingInputArtifactUploadSchema,
+  TrainingInputArtifactSchema,
+  trainingInputArtifactUploadHash,
+  parseAndVerifyTrainingInputArtifactUpload,
+  TrainingJobKindSchema,
+  TrainingJobStateSchema,
+  TrainingCapabilityRequirementSchema,
+  TrainingJobSourceSchema,
+  RewardModelTrainingRequestSchema,
+  TrainingQualificationBaseModelSchema,
+  PolicyOptimizationRequestSchema,
+  TrainingJobRequestSchema,
+  TrainingJobApprovalSchema,
+  TrainingJobSubmissionSchema,
+  trainingJobSubmissionHash,
+  parseAndVerifyTrainingJobSubmission,
+  TrainingJobRecoverySchema,
+  TrainingJobSchema,
+  TrainingJobPageSchema,
+  TrainingJobEventSchema,
+  TrainingJobLogSchema,
+  TrainingJobControlRequestSchema,
+  TrainingJobOutputSchema,
+  TrainingQualificationEvidenceSchema,
+  TrainingExecutionReceiptSchema,
+  trainingExecutionReceiptHash,
+  parseAndVerifyTrainingExecutionReceipt,
+  assertTrainingQualificationReceipt,
+  TrainingJobOutputsSchema,
+  TrainingPolicyLoraCapabilitiesSchema,
+  supportsTrainingPolicyLoraRank,
+  TrainingCapabilitiesSchema,
+  deterministicTrainingRewardSource,
+  TRAINING_EVALUATION_SOURCE_PATH,
+  TrainingEvaluationSourceSchema,
+  assertTrainingEvaluationIsolation,
+  trainingEvaluationSourceRef
+};
+//# sourceMappingURL=chunk-EBB36D5X.js.map