openpond-sdk 0.12.24 → 0.12.25

package/dist/{chunk-QCRNQMN4.js → chunk-IXFUYPGV.js}

@@ -6,7 +6,7 @@ import {
   validateModelStarterExecution,
   validateModelTasksetPackage,
   validateTasksetPackage
-} from "./chunk-ZQ6QTYRE.js";
+} from "./chunk-GV6DEDBU.js";
 import {
   ModelProjectBaseModelSchema,
   ModelProjectRecipeDocumentSchema,
@@ -443,4 +443,4 @@ export {
   previewModelStarter,
   validateResolvedModelStarter
 };
-//# sourceMappingURL=chunk-QCRNQMN4.js.map
+//# sourceMappingURL=chunk-IXFUYPGV.js.map

package/dist/{chunk-Q4RGCEOI.js → chunk-JOMZJXGC.js}

@@ -5,10 +5,10 @@ import {
   computeTasksetHash,
   draftPublishIssues,
   validateTaskset
-} from "./chunk-GCUWJUUM.js";
+} from "./chunk-RTLJV4OS.js";
 import {
   TaskDataRecordSchema
-} from "./chunk-ZQ6QTYRE.js";
+} from "./chunk-GV6DEDBU.js";
 import {
   TasksetDraftFileContentSchema,
   TasksetDraftFileMutationSchema,
@@ -487,4 +487,4 @@ export {
   tasksetDraftFromTaskset,
   publishTasksetDraft
 };
-//# sourceMappingURL=chunk-Q4RGCEOI.js.map
+//# sourceMappingURL=chunk-JOMZJXGC.js.map

package/dist/{chunk-OBI2MQYU.js → chunk-QRYEXPG7.js}

@@ -1,9 +1,3 @@
-import {
-  validateTasksetPackage
-} from "./chunk-ZQ6QTYRE.js";
-import {
-  RunExperimentSchema
-} from "./chunk-ZQFROKKS.js";
 import {
   ExperimentScoringRequestSchema,
   verifyExperimentScoringPass
@@ -11,6 +5,12 @@ import {
 import {
   fetchConnectedJson
 } from "./chunk-O6FKHAWN.js";
+import {
+  validateTasksetPackage
+} from "./chunk-GV6DEDBU.js";
+import {
+  RunExperimentSchema
+} from "./chunk-ZQFROKKS.js";
 import {
   ExperimentExecutionContextSchema,
   ExperimentFieldMappingsSchema,
@@ -652,4 +652,4 @@ export {
   ProfileEvaluationDiscoveryRequestSchema,
   OpenPondProfileEvaluationDiscoveryClient
 };
-//# sourceMappingURL=chunk-OBI2MQYU.js.map
+//# sourceMappingURL=chunk-QRYEXPG7.js.map

package/dist/{chunk-6EZAGTZG.js → chunk-RN5MK7NH.js}

@@ -1,12 +1,12 @@
+import {
+  ExperimentImprovementOptionsSchema
+} from "./chunk-QNOCM5JX.js";
 import {
   EvaluationCoordinationTransport
 } from "./chunk-3B5KSH3V.js";
 import {
   ChatModelRefSchema
 } from "./chunk-H3367ISL.js";
-import {
-  ExperimentImprovementOptionsSchema
-} from "./chunk-QNOCM5JX.js";
 import {
   ImmutableReleaseRefSchema,
   contentHash
@@ -264,4 +264,4 @@ export {
   AdvancedRefinerEvaluationAccountingSchema,
   OpenPondAdvancedRefinerEvaluationClient
 };
-//# sourceMappingURL=chunk-6EZAGTZG.js.map
+//# sourceMappingURL=chunk-RN5MK7NH.js.map

package/dist/{chunk-GCUWJUUM.js → chunk-RTLJV4OS.js}

@@ -11,7 +11,7 @@ import {
   TasksetPreferenceComparisonBindingSchema,
   TasksetPurposeSchema,
   TasksetSourceRefSchema
-} from "./chunk-ZQ6QTYRE.js";
+} from "./chunk-GV6DEDBU.js";
 import {
   ModelTasksetDraftPreparationSchema
 } from "./chunk-TK3DXH7A.js";
@@ -910,4 +910,4 @@ export {
   computeTasksetHash,
   validatePortability
 };
-//# sourceMappingURL=chunk-GCUWJUUM.js.map
+//# sourceMappingURL=chunk-RTLJV4OS.js.map

package/dist/{chunk-GBDBKGXW.js → chunk-T67LNKAK.js}

@@ -2,7 +2,7 @@ import {
   TasksetSchema,
   computeTasksetHash,
   createTasksetDraft
-} from "./chunk-GCUWJUUM.js";
+} from "./chunk-RTLJV4OS.js";
 import {
   GraderFixtureSchema,
   GraderSpecSchema,
@@ -11,7 +11,7 @@ import {
   decodeTasksetPackageFile,
   resolveTasksetPackageInstructions,
   validateTasksetPackage
-} from "./chunk-ZQ6QTYRE.js";
+} from "./chunk-GV6DEDBU.js";
 import {
   contentHash
 } from "./chunk-H3JZ3P5T.js";
@@ -266,4 +266,4 @@ export {
   prepareImportedTasksetPackage,
   tasksetPackageSourceId
 };
-//# sourceMappingURL=chunk-GBDBKGXW.js.map
+//# sourceMappingURL=chunk-T67LNKAK.js.map

package/dist/{chunk-SP7DQEQM.js → chunk-XBFOFTK3.js}

@@ -9,16 +9,16 @@ import {
 } from "./chunk-GPQLBVQC.js";
 import {
   AuthoredTasksetFileInventorySchema
-} from "./chunk-BNBPKCIR.js";
+} from "./chunk-DDCR4KB5.js";
 import {
   configuredTasksetDraftFiles,
   createTasksetDraftWorkspace,
   decodeTasksetDraftWorkspaceFile,
   isManagedTasksetDraftFilePath
-} from "./chunk-Q4RGCEOI.js";
+} from "./chunk-JOMZJXGC.js";
 import {
   TasksetDraftSchema
-} from "./chunk-GCUWJUUM.js";
+} from "./chunk-RTLJV4OS.js";
 import {
   compileModelTasksetReward,
   createTasksetPackage,
@@ -26,7 +26,7 @@ import {
   resolveTasksetPackageExecution,
   resolveTasksetPackageInstructions,
   validateTasksetPackage
-} from "./chunk-ZQ6QTYRE.js";
+} from "./chunk-GV6DEDBU.js";
 import {
   ModelTasksetDraftPreparationSchema,
   TasksetDraftFilePathSchema
@@ -698,4 +698,4 @@ export {
   prepareTasksetDraftSource,
   materializeTasksetDraftWorkspace
 };
-//# sourceMappingURL=chunk-SP7DQEQM.js.map
+//# sourceMappingURL=chunk-XBFOFTK3.js.map

package/dist/{chunk-AG6UJ3DI.js → chunk-YS7DF76T.js}

@@ -1,6 +1,6 @@
 import {
   TasksetDraftWorkspaceSchema
-} from "./chunk-Q4RGCEOI.js";
+} from "./chunk-JOMZJXGC.js";
 import {
   TasksetCatalogReleaseRefSchema
 } from "./chunk-Z252BNAZ.js";
@@ -178,4 +178,4 @@ export {
   ConnectedStartingAssetsReceiptSchema,
   verifyConnectedStartingAssetsReceipt
 };
-//# sourceMappingURL=chunk-AG6UJ3DI.js.map
+//# sourceMappingURL=chunk-YS7DF76T.js.map

package/dist/{chunk-KEG5QS7W.js → chunk-Z5APNTZE.js}

@@ -17,35 +17,159 @@ import {
   canonicalSha256
 } from "./chunk-B3ZHJ2KK.js";
 
-// src/managed-compute-price.ts
+// src/training-recovery.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 id = z.string().trim().min(1).max(191);
+var hash = z.string().regex(/^[a-f0-9]{64}$/);
+var ApprovalBodySchema = z.object({
+  schemaVersion: z.literal("openpond.checkpointRecoveryResourceApproval.v1"),
+  ownerUserId: id,
+  teamId: id,
+  sourceJobId: id,
+  sourceJobVersion: z.number().int().positive(),
+  sourceInputManifestSha256: hash,
+  checkpointId: id,
+  adapterSha256: hash,
+  resumeSha256: hash,
+  idempotencyKey: z.string().trim().min(16).max(191),
+  approvedAt: z.iso.datetime({ offset: true }),
+  maximumSpendUsd: z.number().positive().finite().max(30).refine(
+    (value) => Number(value.toFixed(6)) === value,
+    "Recovery spend must use whole microdollars"
+  ),
+  maximumGpuSeconds: z.number().int().positive().max(21600),
+  maximumWallSeconds: z.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 = z.object({
+  resourceApproval: TrainingCheckpointRecoveryResourceApprovalSchema.optional(),
+  mode: z.literal("evaluation_only").optional(),
+  evaluationGpuType: z.enum(["NVIDIA A100 80GB PCIe", "NVIDIA A100-SXM4-80GB", "NVIDIA H100 80GB HBM3"]).optional(),
+  expectedVersion: z.number().int().positive(),
+  checkpointId: id,
+  idempotencyKey: z.string().trim().min(16).max(191),
+  maximumSpendUsd: z.number().positive().finite(),
+  maximumWallSeconds: z.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 z2 } from "zod";
+var TrainingPhysicalPlacementSchema = z2.object({
+  mode: z2.literal("reuse_only"),
+  physicalWorkerId: z2.string().trim().min(1).max(191),
+  providerPodId: z2.string().trim().min(1).max(191),
+  workerImageDigest: z2.string().regex(/^sha256:[a-f0-9]{64}$/),
+  baseProfileSha256: z2.string().regex(/^[a-f0-9]{64}$/),
+  gpuType: z2.string().trim().min(1).max(200),
+  sourceJobId: z2.string().trim().min(1).max(191),
+  sourceInputManifestSha256: z2.string().regex(/^[a-f0-9]{64}$/),
+  ownerTeamId: z2.string().trim().min(1).max(191),
+  deadlineAt: z2.string().datetime({ offset: true })
+}).strict();
+
+// src/training-queue.ts
+import { z as z3 } from "zod";
+var Timestamp = z3.string().datetime({ offset: true });
+var TrainingQueueStatusSchema = z3.object({
+  ticketId: z3.string().trim().min(1).max(191),
+  ticketNumber: z3.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  label: z3.literal("Waiting for resources"),
+  position: z3.number().int().positive().nullable(),
+  positionScope: z3.literal("compatible_fair_queue"),
+  enqueuedAt: Timestamp,
+  asOf: Timestamp,
+  estimate: z3.object({
+    revision: z3.number().int().nonnegative(),
+    estimatedStartAt: Timestamp,
+    expiresAt: Timestamp,
+    evidence: z3.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 z4 } from "zod";
+var Money = z4.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 = z4.object({
+  schemaVersion: z4.literal("openpond.trainingUsageSnapshot.v1"),
+  asOf: z4.iso.datetime(),
+  customerCapUsd: Money.nullable(),
+  chargedUsd: Money,
+  committedUsd: Money,
+  outstandingUsd: Money,
+  remainingCapUsd: Money.nullable(),
+  availableCreditUsd: Money,
+  complete: z4.boolean(),
+  components: z4.array(z4.object({
+    component: z4.enum(["gpu", "guest", "storage", "judge"]),
+    chargedUsd: Money,
+    committedUsd: Money,
+    outstandingUsd: Money,
+    openOwners: z4.number().int().nonnegative()
+  }).strict()).length(4).refine((values) => values.every((value, index) => value.component === ["gpu", "guest", "storage", "judge"][index]))
+}).strict();
+
+// src/managed-compute-price.ts
+import { z as z5 } from "zod";
+var Hash = z5.string().regex(/^[a-f0-9]{64}$/);
+var Money2 = z5.string().regex(/^(0|[1-9]\d*)(\.\d{1,6})?$/).max(24);
 var micros = (value) => {
-  const [whole, fraction = ""] = Money.parse(value).split(".");
+  const [whole, fraction = ""] = Money2.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"]),
+var ComputeAppliedPriceSchema = z5.object({
+  schemaVersion: z5.literal("openpond.computeAppliedPrice.v1"),
+  version: z5.string().min(1).max(500),
+  service: z5.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;
+  currency: z5.literal("USD"),
+  unit: z5.literal("resource_hour"),
+  hourlyUsd: Money2.refine((value) => {
+    if (!Money2.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)
+var ManagedModificationPriceSchema = z5.object({
+  schemaVersion: z5.literal("openpond.modificationPrice.v1"),
+  appliedPrice: ComputeAppliedPriceSchema.extend({ service: z5.literal("model_modification") }),
+  billingBoundary: z5.literal("active_allocation_until_verified_cleanup"),
+  startupBillable: z5.literal(true),
+  postCompletionIdleBillable: z5.literal(false),
+  minimumBillableSeconds: z5.literal(0),
+  warmReuseSeconds: z5.literal(300)
 }).strict();
 function canonicalComputeSpendCap(value) {
   if (value == null || value.trim() === "") return null;
@@ -63,25 +187,25 @@ async function managedModificationPriceApprovalMatches(plan, command) {
 }
 
 // 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) => {
+import { z as z6 } from "zod";
+var Id = z6.string().min(1).max(500);
+var Hash2 = z6.string().regex(/^[a-f0-9]{64}$/);
+var Price = ComputeAppliedPriceSchema.extend({ service: z6.literal("managed_rl") });
+var Cap = z6.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({
+var Guests = z6.array(z6.object({
   profileHash: Hash2,
   price: Price,
-  resources: z2.object({ cpu: z2.number().positive(), memoryGb: z2.number().positive(), diskGb: z2.number().nonnegative() }).strict()
+  resources: z6.object({ cpu: z6.number().positive(), memoryGb: z6.number().positive(), diskGb: z6.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({
+var Rate = 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 Judges = z6.object({
+  billing: z6.literal("existing_retail_child_captures"),
+  acceptedPricingHashes: z6.array(Hash2).max(64),
+  prices: z6.array(z6.object({
     modelId: Id,
     displayName: Id,
     acceptedPricingHash: Hash2,
@@ -90,8 +214,8 @@ var Judges = z2.object({
     outputUsdPerMillionTokens: Rate,
     cacheWriteUsdPerMillionTokens: Rate.nullable(),
     cacheWriteOneHourUsdPerMillionTokens: Rate.nullable(),
-    longContextThresholdTokens: z2.number().int().positive().nullable(),
-    longContext: z2.object({
+    longContextThresholdTokens: z6.number().int().positive().nullable(),
+    longContext: z6.object({
       inputUsdPerMillionTokens: Rate,
       cachedInputUsdPerMillionTokens: Rate,
       outputUsdPerMillionTokens: Rate,
@@ -99,51 +223,51 @@ var Judges = z2.object({
     }).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()
+var TrainingBillingModesSchema = z6.tuple([
+  z6.object({ mode: z6.literal("prepaid_only"), availability: z6.literal("available"), reason: z6.null() }).strict(),
+  z6.object({
+    mode: z6.literal("actual_usage"),
+    availability: z6.enum(["unavailable", "requires_preparation"]),
+    reason: z6.string().min(1).max(500).nullable()
   }).strict()
 ]);
-var TrainingUsageFundingRequestSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingUsageFundingRequest.v1"),
-  billingMode: z2.literal("actual_usage"),
+var TrainingUsageFundingRequestSchema = z6.object({
+  schemaVersion: z6.literal("openpond.trainingUsageFundingRequest.v1"),
+  billingMode: z6.literal("actual_usage"),
   customerCapUsd: Cap
 }).strict();
-var TrainingUsageQualificationRefSchema = z2.object({
-  authorizationId: z2.uuid(),
+var TrainingUsageQualificationRefSchema = z6.object({
+  authorizationId: z6.uuid(),
   operationId: Id,
   authorizationSha256: Hash2
 }).strict();
-var TrainingUsageQuoteContentSchema = z2.object({
-  schemaVersion: z2.literal("openpond.trainingUsageQuote.v1"),
+var TrainingUsageQuoteContentSchema = z6.object({
+  schemaVersion: z6.literal("openpond.trainingUsageQuote.v1"),
   teamId: Id,
   actorUserId: Id,
   preparationId: Id,
   submissionHash: Hash2,
-  workerImageDigest: z2.string().regex(/^sha256:[a-f0-9]{64}$/),
+  workerImageDigest: z6.string().regex(/^sha256:[a-f0-9]{64}$/),
   customerCapUsd: Cap,
-  maximumWallSeconds: z2.number().int().positive(),
-  retentionDays: z2.number().int().nonnegative(),
+  maximumWallSeconds: z6.number().int().positive(),
+  retentionDays: z6.number().int().nonnegative(),
   qualification: TrainingUsageQualificationRefSchema.optional(),
   gpu: Price,
   guests: Guests,
   judges: Judges,
-  storage: z2.object({
+  storage: z6.object({
     price: Price,
-    storageClass: z2.literal("STANDARD"),
-    quantityBasis: z2.literal("gib_milliseconds"),
-    onCreditExhaustion: z2.literal("retain_objects_and_stop_new_storage")
+    storageClass: z6.literal("STANDARD"),
+    quantityBasis: z6.literal("gib_milliseconds"),
+    onCreditExhaustion: z6.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()
+  gpuBillingBoundary: z6.literal("active_allocation_until_verified_cleanup"),
+  storageBillingBoundary: z6.literal("accepted_retention_window"),
+  startupBillable: z6.literal(true),
+  postCompletionIdleBillable: z6.literal(false),
+  minimumBillableSeconds: z6.literal(0),
+  issuedAt: z6.iso.datetime(),
+  expiresAt: z6.iso.datetime()
 }).strict();
 var TrainingUsageQuoteSchema = TrainingUsageQuoteContentSchema.extend({ contentHash: Hash2, signature: Id }).strict();
 async function verifyTrainingUsageQuote(raw, expected) {
@@ -153,130 +277,6 @@ async function verifyTrainingUsageQuote(raw, expected) {
   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";
@@ -817,6 +817,12 @@ async function trainingEvaluationSourceRef(input) {
 }
 
 export {
+  TrainingCheckpointRecoveryResourceApprovalSchema,
+  createTrainingCheckpointRecoveryResourceApproval,
+  TrainingCheckpointRecoveryRequestSchema,
+  TrainingPhysicalPlacementSchema,
+  TrainingQueueStatusSchema,
+  TrainingUsageSnapshotSchema,
   ComputeAppliedPriceSchema,
   ManagedModificationPriceSchema,
   canonicalComputeSpendCap,
@@ -828,12 +834,6 @@ export {
   TrainingUsageQuoteContentSchema,
   TrainingUsageQuoteSchema,
   verifyTrainingUsageQuote,
-  TrainingCheckpointRecoveryResourceApprovalSchema,
-  createTrainingCheckpointRecoveryResourceApproval,
-  TrainingCheckpointRecoveryRequestSchema,
-  TrainingPhysicalPlacementSchema,
-  TrainingQueueStatusSchema,
-  TrainingUsageSnapshotSchema,
   TrainingInputArtifactUploadSchema,
   TrainingInputArtifactSchema,
   trainingInputArtifactUploadHash,
@@ -872,4 +872,4 @@ export {
   assertTrainingEvaluationIsolation,
   trainingEvaluationSourceRef
 };
-//# sourceMappingURL=chunk-KEG5QS7W.js.map
+//# sourceMappingURL=chunk-Z5APNTZE.js.map