openpond-sdk 0.12.9 → 0.12.10

package/dist/chunk-B3ZHJ2KK.js

@@ -0,0 +1,152 @@
+// src/protocol.ts
+var OPENPOND_TRAINING_PROTOCOL_MAJOR = 2;
+var OPENPOND_TRAINING_MEDIA_TYPE = "application/vnd.openpond.training+json;version=2";
+var OPENPOND_MODEL_PROJECT_MEDIA_TYPE = "application/vnd.openpond.model-project+json;version=2";
+var TRAINING_JOB_SUBMISSION_MAX_BYTES = 1048576;
+var TRAINING_INPUT_ARTIFACT_MAX_BYTES = 67108864;
+var TRAINING_API_RESPONSE_MAX_BYTES = 8388608;
+var MODEL_PROJECT_SYNC_MAX_BYTES = 524288;
+var MODEL_PROJECT_API_RESPONSE_MAX_BYTES = 8388608;
+var OpenPondProtocolError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OpenPondProtocolError";
+    this.code = code;
+  }
+};
+function canonicalJson(value) {
+  return JSON.stringify(normalizeCanonicalJson(value));
+}
+function canonicalJsonByteLength(value) {
+  return new TextEncoder().encode(canonicalJson(value)).byteLength;
+}
+async function canonicalSha256(value) {
+  const bytes = new TextEncoder().encode(canonicalJson(value));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+function assertCanonicalPayloadSize(value, maximumBytes, label) {
+  const actualBytes = canonicalJsonByteLength(value);
+  if (actualBytes > maximumBytes) {
+    throw new OpenPondProtocolError(
+      "payload_too_large",
+      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`
+    );
+  }
+}
+function parseBoundedJson(text, maximumBytes, label) {
+  const actualBytes = new TextEncoder().encode(text).byteLength;
+  if (actualBytes > maximumBytes) {
+    throw new OpenPondProtocolError(
+      "response_too_large",
+      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new OpenPondProtocolError(
+      "invalid_json",
+      `${label} was not valid JSON.`
+    );
+  }
+}
+async function readBoundedJsonResponse(response, maximumBytes, label) {
+  const reader = response.body?.getReader();
+  if (!reader) return parseBoundedJson("", maximumBytes, label);
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > maximumBytes) {
+        throw new OpenPondProtocolError(
+          "response_too_large",
+          `${label} exceeds the maximum of ${maximumBytes} bytes.`
+        );
+      }
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    text += decoder.decode();
+    return parseBoundedJson(text, maximumBytes, label);
+  } catch (error) {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+    throw error;
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+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 = /* @__PURE__ */ Object.create(null);
+    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}.`
+  );
+}
+
+export {
+  OPENPOND_TRAINING_PROTOCOL_MAJOR,
+  OPENPOND_TRAINING_MEDIA_TYPE,
+  OPENPOND_MODEL_PROJECT_MEDIA_TYPE,
+  TRAINING_JOB_SUBMISSION_MAX_BYTES,
+  TRAINING_INPUT_ARTIFACT_MAX_BYTES,
+  TRAINING_API_RESPONSE_MAX_BYTES,
+  MODEL_PROJECT_SYNC_MAX_BYTES,
+  MODEL_PROJECT_API_RESPONSE_MAX_BYTES,
+  OpenPondProtocolError,
+  canonicalJson,
+  canonicalJsonByteLength,
+  canonicalSha256,
+  assertCanonicalPayloadSize,
+  parseBoundedJson,
+  readBoundedJsonResponse
+};
+//# sourceMappingURL=chunk-B3ZHJ2KK.js.map

package/dist/chunk-B3ZHJ2KK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/protocol.ts"],"sourcesContent":["export type CanonicalJsonValue =\n  | null\n  | boolean\n  | number\n  | string\n  | CanonicalJsonValue[]\n  | { [key: string]: CanonicalJsonValue };\n\nexport const OPENPOND_TRAINING_PROTOCOL_MAJOR = 2 as const;\nexport const OPENPOND_TRAINING_MEDIA_TYPE =\n  \"application/vnd.openpond.training+json;version=2\" as const;\nexport const OPENPOND_MODEL_PROJECT_MEDIA_TYPE =\n  \"application/vnd.openpond.model-project+json;version=2\" as const;\n\nexport const TRAINING_JOB_SUBMISSION_MAX_BYTES = 1_048_576;\nexport const TRAINING_INPUT_ARTIFACT_MAX_BYTES = 67_108_864;\nexport const TRAINING_API_RESPONSE_MAX_BYTES = 8_388_608;\nexport const MODEL_PROJECT_SYNC_MAX_BYTES = 524_288;\nexport const MODEL_PROJECT_API_RESPONSE_MAX_BYTES = 8_388_608;\n\nexport class OpenPondProtocolError extends Error {\n  readonly code: string;\n\n  constructor(code: string, message: string) {\n    super(message);\n    this.name = \"OpenPondProtocolError\";\n    this.code = code;\n  }\n}\n\n/**\n * Deterministic JSON used for content-addressed OpenPond protocol objects.\n * Object keys are sorted by Unicode code point, arrays retain their authored\n * order, and non-JSON/non-finite values are rejected rather than coerced.\n */\nexport function canonicalJson(value: unknown): string {\n  return JSON.stringify(normalizeCanonicalJson(value));\n}\n\nexport function canonicalJsonByteLength(value: unknown): number {\n  return new TextEncoder().encode(canonicalJson(value)).byteLength;\n}\n\nexport async function canonicalSha256(value: unknown): Promise<string> {\n  const bytes = new TextEncoder().encode(canonicalJson(value));\n  const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", bytes);\n  return Array.from(new Uint8Array(digest), (byte) =>\n    byte.toString(16).padStart(2, \"0\"),\n  ).join(\"\");\n}\n\nexport function assertCanonicalPayloadSize(\n  value: unknown,\n  maximumBytes: number,\n  label: string,\n): void {\n  const actualBytes = canonicalJsonByteLength(value);\n  if (actualBytes > maximumBytes) {\n    throw new OpenPondProtocolError(\n      \"payload_too_large\",\n      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`,\n    );\n  }\n}\n\nexport function parseBoundedJson(\n  text: string,\n  maximumBytes: number,\n  label: string,\n): unknown {\n  const actualBytes = new TextEncoder().encode(text).byteLength;\n  if (actualBytes > maximumBytes) {\n    throw new OpenPondProtocolError(\n      \"response_too_large\",\n      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`,\n    );\n  }\n  try {\n    return JSON.parse(text) as unknown;\n  } catch {\n    throw new OpenPondProtocolError(\n      \"invalid_json\",\n      `${label} was not valid JSON.`,\n    );\n  }\n}\n\n/** Bound the wire body while consuming it, before allocating the complete JSON\n * string. Reader cleanup must never replace the original transport/JSON error. */\nexport async function readBoundedJsonResponse(\n  response: Response,\n  maximumBytes: number,\n  label: string,\n): Promise<unknown> {\n  const reader = response.body?.getReader();\n  if (!reader) return parseBoundedJson(\"\", maximumBytes, label);\n  const decoder = new TextDecoder();\n  let bytes = 0;\n  let text = \"\";\n  try {\n    for (;;) {\n      const chunk = await reader.read();\n      if (chunk.done) break;\n      bytes += chunk.value.byteLength;\n      if (bytes > maximumBytes) {\n        throw new OpenPondProtocolError(\n          \"response_too_large\",\n          `${label} exceeds the maximum of ${maximumBytes} bytes.`,\n        );\n      }\n      text += decoder.decode(chunk.value, { stream: true });\n    }\n    text += decoder.decode();\n    return parseBoundedJson(text, maximumBytes, label);\n  } catch (error) {\n    try { await reader.cancel(); } catch { /* Preserve the primary failure. */ }\n    throw error;\n  } finally {\n    try { reader.releaseLock(); } catch { /* Never mask a transport/parse failure. */ }\n  }\n}\n\nfunction normalizeCanonicalJson(value: unknown): CanonicalJsonValue {\n  if (\n    value === null ||\n    typeof value === \"string\" ||\n    typeof value === \"boolean\"\n  ) {\n    return value;\n  }\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value)) {\n      throw new OpenPondProtocolError(\n        \"non_json_value\",\n        \"Canonical JSON cannot contain a non-finite number.\",\n      );\n    }\n    return Object.is(value, -0) ? 0 : value;\n  }\n  if (Array.isArray(value)) {\n    return value.map((entry) => normalizeCanonicalJson(entry));\n  }\n  if (typeof value === \"object\") {\n    const prototype = Object.getPrototypeOf(value);\n    if (prototype !== Object.prototype && prototype !== null) {\n      throw new OpenPondProtocolError(\n        \"non_json_value\",\n        \"Canonical JSON accepts only plain objects.\",\n      );\n    }\n    const result: Record<string, CanonicalJsonValue> = Object.create(null);\n    for (const key of Object.keys(value as Record<string, unknown>).sort()) {\n      const entry = (value as Record<string, unknown>)[key];\n      if (entry === undefined || typeof entry === \"function\" || typeof entry === \"symbol\") {\n        throw new OpenPondProtocolError(\n          \"non_json_value\",\n          `Canonical JSON cannot contain ${typeof entry} at ${key}.`,\n        );\n      }\n      result[key] = normalizeCanonicalJson(entry);\n    }\n    return result;\n  }\n  throw new OpenPondProtocolError(\n    \"non_json_value\",\n    `Canonical JSON cannot contain ${typeof value}.`,\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-YSEYPMQ3.js → chunk-BQ2C2Y54.js}

@@ -1,3 +1,12 @@
+import {
+  MODEL_PROJECT_API_RESPONSE_MAX_BYTES,
+  MODEL_PROJECT_SYNC_MAX_BYTES,
+  OPENPOND_MODEL_PROJECT_MEDIA_TYPE,
+  OpenPondProtocolError,
+  assertCanonicalPayloadSize,
+  canonicalSha256,
+  readBoundedJsonResponse
+} from "./chunk-B3ZHJ2KK.js";
 import {
   ModelInitialLearningSchema
 } from "./chunk-CL3IOOVL.js";
@@ -10,8 +19,8 @@ import { z } from "zod";
 var Id = z.string().trim().min(1).max(191);
 var Hash = z.string().regex(/^[a-f0-9]{64}$/);
 var TrainingGpuSelectionSchema = z.discriminatedUnion("mode", [
-  z.object({ mode: z.literal("automatic"), objective: z.enum(["balanced", "fast", "economical"]) }).strict(),
-  z.object({ mode: z.literal("manual"), availabilityId: Id, gpuType: z.string().trim().min(1).max(256) }).strict()
+  z.object({ mode: z.literal("automatic"), objective: z.enum(["balanced", "fast", "economical"]), gpuCount: z.union([z.literal(1), z.literal(2)]).optional() }).strict(),
+  z.object({ mode: z.literal("manual"), availabilityId: Id, gpuType: z.string().trim().min(1).max(256), gpuCount: z.union([z.literal(1), z.literal(2)]).optional() }).strict()
 ]);
 var TrainingEstimateReviewSchema = z.object({
   estimateId: Id,
@@ -45,142 +54,6 @@ var TrainingGpuCatalogSchema = z.object({
 
 // src/model-projects.ts
 import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-
-// src/protocol.ts
-var OPENPOND_TRAINING_PROTOCOL_MAJOR = 2;
-var OPENPOND_TRAINING_MEDIA_TYPE = "application/vnd.openpond.training+json;version=2";
-var OPENPOND_MODEL_PROJECT_MEDIA_TYPE = "application/vnd.openpond.model-project+json;version=2";
-var TRAINING_JOB_SUBMISSION_MAX_BYTES = 1048576;
-var TRAINING_INPUT_ARTIFACT_MAX_BYTES = 67108864;
-var TRAINING_API_RESPONSE_MAX_BYTES = 8388608;
-var MODEL_PROJECT_SYNC_MAX_BYTES = 524288;
-var MODEL_PROJECT_API_RESPONSE_MAX_BYTES = 8388608;
-var OpenPondProtocolError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "OpenPondProtocolError";
-    this.code = code;
-  }
-};
-function canonicalJson(value) {
-  return JSON.stringify(normalizeCanonicalJson(value));
-}
-function canonicalJsonByteLength(value) {
-  return new TextEncoder().encode(canonicalJson(value)).byteLength;
-}
-async function canonicalSha256(value) {
-  const bytes = new TextEncoder().encode(canonicalJson(value));
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-  return Array.from(
-    new Uint8Array(digest),
-    (byte) => byte.toString(16).padStart(2, "0")
-  ).join("");
-}
-function assertCanonicalPayloadSize(value, maximumBytes, label) {
-  const actualBytes = canonicalJsonByteLength(value);
-  if (actualBytes > maximumBytes) {
-    throw new OpenPondProtocolError(
-      "payload_too_large",
-      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`
-    );
-  }
-}
-function parseBoundedJson(text, maximumBytes, label) {
-  const actualBytes = new TextEncoder().encode(text).byteLength;
-  if (actualBytes > maximumBytes) {
-    throw new OpenPondProtocolError(
-      "response_too_large",
-      `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`
-    );
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new OpenPondProtocolError(
-      "invalid_json",
-      `${label} was not valid JSON.`
-    );
-  }
-}
-async function readBoundedJsonResponse(response, maximumBytes, label) {
-  const reader = response.body?.getReader();
-  if (!reader) return parseBoundedJson("", maximumBytes, label);
-  const decoder = new TextDecoder();
-  let bytes = 0;
-  let text = "";
-  try {
-    for (; ; ) {
-      const chunk = await reader.read();
-      if (chunk.done) break;
-      bytes += chunk.value.byteLength;
-      if (bytes > maximumBytes) {
-        throw new OpenPondProtocolError(
-          "response_too_large",
-          `${label} exceeds the maximum of ${maximumBytes} bytes.`
-        );
-      }
-      text += decoder.decode(chunk.value, { stream: true });
-    }
-    text += decoder.decode();
-    return parseBoundedJson(text, maximumBytes, label);
-  } catch (error) {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-    throw error;
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-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 = /* @__PURE__ */ Object.create(null);
-    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 = z2.string().trim().min(1).max(500);
 var HashSchema = z2.string().regex(/^[a-f0-9]{64}$/);
 var TimestampSchema = z2.string().datetime({ offset: true });
@@ -539,21 +412,6 @@ export {
   TrainingGpuSelectionSchema,
   TrainingEstimateReviewSchema,
   TrainingGpuCatalogSchema,
-  OPENPOND_TRAINING_PROTOCOL_MAJOR,
-  OPENPOND_TRAINING_MEDIA_TYPE,
-  OPENPOND_MODEL_PROJECT_MEDIA_TYPE,
-  TRAINING_JOB_SUBMISSION_MAX_BYTES,
-  TRAINING_INPUT_ARTIFACT_MAX_BYTES,
-  TRAINING_API_RESPONSE_MAX_BYTES,
-  MODEL_PROJECT_SYNC_MAX_BYTES,
-  MODEL_PROJECT_API_RESPONSE_MAX_BYTES,
-  OpenPondProtocolError,
-  canonicalJson,
-  canonicalJsonByteLength,
-  canonicalSha256,
-  assertCanonicalPayloadSize,
-  parseBoundedJson,
-  readBoundedJsonResponse,
   ModelProjectImmutableRefSchema,
   ModelProjectVersionedRefSchema,
   ModelProjectBaseModelSchema,
@@ -581,4 +439,4 @@ export {
   OpenPondModelProjectApiError,
   createModelProjectsClient
 };
-//# sourceMappingURL=chunk-YSEYPMQ3.js.map
+//# sourceMappingURL=chunk-BQ2C2Y54.js.map

package/dist/chunk-BQ2C2Y54.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/model-projects.ts","../src/training-compute-selection.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { TrainingGpuSelectionSchema } from \"./training-compute-selection.js\";\nimport { ModelInitialLearningSchema, type ModelInitialLearning } from \"./model-learning-intent.js\";\nexport { ModelInitialLearningSchema, type ModelInitialLearning } from \"./model-learning-intent.js\";\nimport { assertBoundedTaskJson } from \"@openpond/evals/task-schema\";\n\nimport {\n  MODEL_PROJECT_API_RESPONSE_MAX_BYTES,\n  MODEL_PROJECT_SYNC_MAX_BYTES,\n  OPENPOND_MODEL_PROJECT_MEDIA_TYPE,\n  OpenPondProtocolError,\n  assertCanonicalPayloadSize,\n  canonicalSha256,\n  readBoundedJsonResponse,\n} from \"./protocol.js\";\n\nexport {\n  MODEL_PROJECT_API_RESPONSE_MAX_BYTES,\n  MODEL_PROJECT_SYNC_MAX_BYTES,\n  OPENPOND_MODEL_PROJECT_MEDIA_TYPE,\n} from \"./protocol.js\";\n\nconst IdSchema = z.string().trim().min(1).max(500);\nconst HashSchema = z.string().regex(/^[a-f0-9]{64}$/);\nconst TimestampSchema = z.string().datetime({ offset: true });\n\nexport const ModelProjectImmutableRefSchema = z\n  .object({\n    id: IdSchema,\n    contentHash: HashSchema,\n  })\n  .strict();\n\nexport const ModelProjectVersionedRefSchema =\n  ModelProjectImmutableRefSchema.extend({\n    revision: z.number().int().positive(),\n  }).strict();\n\nexport const ModelProjectBaseModelSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.baseModelPreference.v1\"),\n    modelId: IdSchema,\n    revision: z.string().trim().min(1).max(256).nullable(),\n    tokenizerRevision: z.string().trim().min(1).max(256).nullable(),\n    chatTemplateHash: z.string().trim().min(8).max(256).nullable(),\n    modelAssetId: IdSchema.nullable(),\n    source: z.enum([\"managed\", \"local\", \"builtin\"]),\n  })\n  .strict();\n\nexport const ModelProjectTrainingMethodSchema = z.enum([\n  \"sft\",\n  \"dpo\",\n  \"grpo\",\n  \"ppo\",\n  \"sdft\",\n  \"opd\",\n  \"opsd\",\n  \"sdpo\",\n]);\n\n/**\n * A versioned recipe document stored while a Project is still mutable.\n * The training endpoint validates the selected recipe version in full before\n * accepting an immutable Job; Project sync preserves newer recipe fields.\n */\nexport const ModelProjectRecipeDocumentSchema = z\n  .object({\n    schemaVersion: z.string().regex(/^openpond\\.[A-Za-z0-9]+Recipe\\.v\\d+$/),\n    method: ModelProjectTrainingMethodSchema,\n    parameterization: z.enum([\"lora\", \"full\"]),\n  })\n  .catchall(z.unknown());\n\n/** The published Profile source selected for this Model's Harness. */\nexport const ModelProfileSourceSelectionSchema = z.object({\n  profileProjectId: IdSchema,\n  sourceRevision: z.string().regex(/^[a-f0-9]{40,64}$/),\n  harnessRelease: ModelProjectImmutableRefSchema,\n}).strict();\n\n/** A held-out check selected from an exact released Profile catalog. Its\n * Taskset and grader stay in the evaluation runtime, outside training input. */\nexport const ModelProfileEvaluationSelectionSchema = z.object({\n  profileProjectId: IdSchema,\n  sourceRevision: z.string().regex(/^[a-f0-9]{40,64}$/),\n  catalogHash: HashSchema,\n  definitionId: IdSchema,\n  harnessRelease: ModelProjectImmutableRefSchema,\n  tasksetRelease: ModelProjectImmutableRefSchema,\n}).strict();\n\nexport const ModelProjectTrainingSetupSchema = z\n  .object({\n    tasksetRef: ModelProjectVersionedRefSchema.nullable().default(null),\n    evaluationTasksetRef: ModelProjectVersionedRefSchema.nullable().optional(),\n    profileSource: ModelProfileSourceSelectionSchema.nullable().optional(),\n    profileEvaluation: ModelProfileEvaluationSelectionSchema.nullable().optional(),\n    rewardBindingRef: ModelProjectVersionedRefSchema.nullable().optional(),\n    tasksetRelease: ModelProjectImmutableRefSchema.nullable().default(null),\n    harnessRelease: ModelProjectImmutableRefSchema.nullable().default(null),\n    baseModel: ModelProjectBaseModelSchema.nullable().default(null),\n    method: ModelProjectTrainingMethodSchema.nullable().default(null),\n    destinationId: IdSchema.nullable().default(null),\n    managedRolloutPlacement: z\n      .enum([\"local\", \"remote\"])\n      .default(\"remote\"),\n    managedGpuPlacementObjective: z\n      .enum([\"fast\", \"balanced\", \"economical\"])\n      .default(\"balanced\"),\n    managedGpuSelection: TrainingGpuSelectionSchema.optional(),\n    continuationAdapterMode: z.enum([\"residual_append\", \"shared\", \"sequential_merge\"]).optional(),\n    managedGpuRequirement: z\n      .enum([\"any\", \"h100_hbm3\"])\n      .default(\"any\"),\n    runPreset: z\n      .enum([\"small\", \"standard\", \"custom\", \"small_experiment\"])\n      .nullable()\n      .default(null),\n    recipe: ModelProjectRecipeDocumentSchema.nullable().default(null),\n    preferredMaximumSpendUsd: z.number().nonnegative().nullable().default(null),\n    preferredRetentionDays: z\n      .number()\n      .int()\n      .nonnegative()\n      .nullable()\n      .default(null),\n  })\n  .strict();\n\nexport const HostedModelProjectTrainingSetupSchema =\n  ModelProjectTrainingSetupSchema;\n\nexport const HostedModelProjectLinkSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.hostedModelProjectLink.v1\"),\n    apiOrigin: z.string().url().refine(value => new URL(value).origin === value, \"Use a canonical API origin.\").nullable().default(null),\n    teamId: IdSchema,\n    projectId: IdSchema,\n    portableProjectId: IdSchema,\n    revision: z.number().int().positive(),\n    etag: HashSchema,\n    syncedSourceRevision: z.number().int().positive(),\n    syncedAt: TimestampSchema,\n    tasksets: z\n      .array(\n        z\n          .object({\n            localTasksetId: IdSchema,\n            localTasksetHash: HashSchema.nullable().default(null),\n            releaseId: IdSchema,\n            releaseRevision: z.number().int().positive(),\n            releaseHash: HashSchema,\n            packageHash: HashSchema.nullable().default(null),\n            hostedTasksetId: IdSchema,\n            syncedAt: TimestampSchema,\n          })\n          .strict(),\n      )\n      .max(10_000)\n      .default([]),\n  })\n  .strict();\n\nexport const ModelProjectTasksetSyncSchema = z\n  .object({\n    localTasksetId: IdSchema,\n    releaseId: IdSchema,\n    releaseRevision: z.number().int().positive(),\n    releaseHash: HashSchema,\n    state: z.enum([\"syncing\", \"synced\", \"sync_failed\"]),\n    hostedTasksetId: IdSchema.nullable().default(null),\n    lastAttemptAt: TimestampSchema,\n    syncedAt: TimestampSchema.nullable().default(null),\n    lastError: z.string().trim().min(1).max(5_000).nullable().default(null),\n  })\n  .strict();\n\nexport const ModelProjectSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.modelProject.v2\"),\n    id: IdSchema,\n    profileId: IdSchema,\n    revision: z.number().int().positive().default(1),\n    name: z.string().trim().min(1).max(200),\n    objective: z.string().trim().max(5_000).nullable(),\n    defaultBaseModel: ModelProjectBaseModelSchema.nullable(),\n    defaultDestinationId: IdSchema.nullable(),\n    trainingSetup: ModelProjectTrainingSetupSchema,\n    hosted: HostedModelProjectLinkSchema.nullable().default(null),\n    tasksetSyncs: z\n      .array(ModelProjectTasksetSyncSchema)\n      .max(10_000)\n      .default([]),\n    createdAt: TimestampSchema,\n    updatedAt: TimestampSchema,\n  })\n  .strict();\n\n/** User-editable configuration. Execution and hosting receipts are server-owned. */\nexport const ModelProjectEditableSchema = ModelProjectSchema.pick({\n  id: true,\n  profileId: true,\n  name: true,\n  objective: true,\n  defaultBaseModel: true,\n  defaultDestinationId: true,\n  trainingSetup: true,\n});\n\n/** Zero creates a new Model; a positive revision updates that exact revision. */\nexport const ModelProjectSaveRequestSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelProjectSave.v1\"),\n  operationId: IdSchema,\n  expectedRevision: z.number().int().nonnegative(),\n  project: ModelProjectEditableSchema,\n  learning: ModelInitialLearningSchema.optional(),\n}).strict().superRefine((value, context) => {\n  if (value.learning && value.expectedRevision !== 0) context.addIssue({ code: \"custom\", path: [\"learning\"], message: \"Use learning settings to edit an existing Model's policy.\" });\n});\n\nexport type ModelProjectSaveRequest = z.infer<typeof ModelProjectSaveRequestSchema>;\n\n/** A read-only configuration check; it does not establish training or grader quality. */\nexport const ModelProjectConfigurationCheckSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelProjectConfigurationCheck.v1\"),\n  configurationHash: HashSchema,\n  projectId: IdSchema,\n  expectedRevision: z.number().int().nonnegative(),\n  checkedAt: TimestampSchema,\n  canSave: z.boolean(),\n  deferred: z.array(z.enum([\"base_model\", \"taskset\"])).max(2),\n  findings: z.array(z.object({\n    code: IdSchema,\n    severity: z.enum([\"error\", \"warning\"]),\n    message: z.string().min(1).max(5000),\n    field: z.string().min(1).max(500).nullable(),\n  }).strict()).max(100),\n}).strict();\n\nexport type ModelProjectConfigurationCheck = z.infer<typeof ModelProjectConfigurationCheckSchema>;\n\nexport const ModelProjectBaseModelCandidateSchema = z.object({\n  id: IdSchema, name: z.string().min(1).max(500), available: z.boolean(), preference: ModelProjectBaseModelSchema,\n}).strict();\n\nexport async function modelProjectConfigurationHash(request: ModelProjectSaveRequest): Promise<string> {\n  const parsed = parseModelProjectSaveRequest(request);\n  return canonicalSha256({ project: parsed.project, expectedRevision: parsed.expectedRevision, ...(parsed.learning ? { learning: parsed.learning } : {}) });\n}\n\nexport function parseModelProjectSaveRequest(value: unknown): ModelProjectSaveRequest {\n  try {\n    assertBoundedTaskJson(value, MODEL_PROJECT_SYNC_MAX_BYTES);\n  } catch {\n    throw new OpenPondModelProjectApiError(400, {\n      schemaVersion: \"openpond.modelProjectApiError.v2\", code: \"model_configuration_json_invalid\",\n      message: \"Model configuration must be bounded JSON data.\", retryable: false, requestId: null, details: {},\n    });\n  }\n  return ModelProjectSaveRequestSchema.parse(value);\n}\n\n/** Stable across transport retries; excludes server-owned revision/timestamps. */\nexport async function createModelProjectSaveRequest(\n  project: z.input<typeof ModelProjectEditableSchema>,\n  expectedRevision: number,\n  learning?: ModelInitialLearning,\n): Promise<ModelProjectSaveRequest> {\n  assertBoundedTaskJson(project, MODEL_PROJECT_SYNC_MAX_BYTES);\n  const editable = ModelProjectEditableSchema.parse(project);\n  assertCanonicalPayloadSize(editable, MODEL_PROJECT_SYNC_MAX_BYTES, \"Model configuration\");\n  const initialLearning = learning ? ModelInitialLearningSchema.parse(learning) : undefined;\n  const hash = await canonicalSha256({ project: editable, expectedRevision, ...(initialLearning ? { learning: initialLearning } : {}) });\n  return parseModelProjectSaveRequest({\n    schemaVersion: \"openpond.modelProjectSave.v1\",\n    operationId: `model-save:${hash}`,\n    expectedRevision,\n    project: editable,\n    ...(initialLearning ? { learning: initialLearning } : {}),\n  });\n}\n\nexport const HostedModelProjectSyncSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.hostedModelProjectSync.v2\"),\n    portableProjectId: IdSchema,\n    name: z.string().trim().min(1).max(200),\n    objective: z.string().trim().max(5_000).nullable(),\n    defaultBaseModel: ModelProjectBaseModelSchema.nullable(),\n    defaultDestinationId: IdSchema.nullable(),\n    trainingSetup: HostedModelProjectTrainingSetupSchema,\n    sourceRevision: z.number().int().positive(),\n    sourceUpdatedAt: TimestampSchema,\n    expectedEtag: HashSchema.nullable().default(null),\n  })\n  .strict();\n\nexport const HostedModelProjectSummarySchema = z\n  .object({\n    id: IdSchema,\n    teamId: IdSchema,\n    portableProjectId: IdSchema,\n    name: z.string().trim().min(1).max(200),\n    objective: z.string().trim().max(5_000).nullable(),\n    defaultBaseModel: ModelProjectBaseModelSchema.nullable(),\n    defaultDestinationId: IdSchema.nullable(),\n    trainingSetup: HostedModelProjectTrainingSetupSchema,\n    sourceRevision: z.number().int().positive(),\n    sourceUpdatedAt: TimestampSchema,\n    revision: z.number().int().positive(),\n    etag: HashSchema,\n    createdAt: TimestampSchema,\n    updatedAt: TimestampSchema,\n  })\n  .strict();\n\nexport const ModelProjectResourceSummarySchema = z\n  .object({\n    kind: z.enum([\n      \"taskset_release\",\n      \"harness_release\",\n      \"dataset_release\",\n      \"evidence_set\",\n      \"model_version\",\n      \"reward_model_version\",\n      \"evaluation_receipt\",\n    ]),\n    ref: ModelProjectImmutableRefSchema,\n    role: z.string().trim().min(1).max(200).nullable().default(null),\n    updatedAt: TimestampSchema,\n  })\n  .strict();\n\nexport const HostedModelProjectDetailSchema = z\n  .object({\n    project: HostedModelProjectSummarySchema,\n    resources: z.array(ModelProjectResourceSummarySchema).max(10_000),\n    jobCount: z.number().int().nonnegative(),\n    latestJobIds: z.array(IdSchema).max(100),\n  })\n  .strict();\n\nexport const ModelProjectApiErrorSchema = z\n  .object({\n    schemaVersion: z.literal(\"openpond.modelProjectApiError.v2\"),\n    code: z.string().trim().min(1).max(200),\n    message: z.string().trim().min(1).max(5_000),\n    retryable: z.boolean().default(false),\n    requestId: z.string().trim().min(1).max(500).nullable().default(null),\n    details: z.record(z.string(), z.unknown()).default({}),\n  })\n  .strict();\n\nexport class OpenPondModelProjectApiError extends Error {\n  readonly status: number;\n  readonly code: string;\n  readonly retryable: boolean;\n  readonly requestId: string | null;\n  readonly details: Record<string, unknown>;\n\n  constructor(status: number, error: z.infer<typeof ModelProjectApiErrorSchema>) {\n    super(error.message);\n    this.name = \"OpenPondModelProjectApiError\";\n    this.status = status;\n    this.code = error.code;\n    this.retryable = error.retryable;\n    this.requestId = error.requestId;\n    this.details = error.details;\n  }\n}\n\nexport type ModelProject = z.infer<typeof ModelProjectSchema>;\nexport type ModelProjectTrainingSetup = z.infer<\n  typeof ModelProjectTrainingSetupSchema\n>;\nexport type HostedModelProjectSync = z.infer<\n  typeof HostedModelProjectSyncSchema\n>;\nexport type HostedModelProjectSummary = z.infer<\n  typeof HostedModelProjectSummarySchema\n>;\nexport type HostedModelProjectDetail = z.infer<\n  typeof HostedModelProjectDetailSchema\n>;\n\ntype ModelProjectsFetch = typeof fetch;\n\nfunction headersRecord(headers: HeadersInit | undefined): Record<string, string> {\n  const result: Record<string, string> = {};\n  new Headers(headers).forEach((value, key) => {\n    result[key] = value;\n  });\n  return result;\n}\n\nexport function createModelProjectsClient(input: {\n  baseUrl: string;\n  fetch?: ModelProjectsFetch;\n  headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);\n}) {\n  const fetchImpl = input.fetch ?? fetch;\n  const baseUrl = input.baseUrl.replace(/\\/$/, \"\");\n\n  async function request(pathname: string, init?: RequestInit): Promise<unknown> {\n    const configuredHeaders =\n      typeof input.headers === \"function\"\n        ? await input.headers()\n        : (input.headers ?? {});\n    const response = await fetchImpl(`${baseUrl}${pathname}`, {\n      ...init,\n      headers: {\n        accept: OPENPOND_MODEL_PROJECT_MEDIA_TYPE,\n        ...(init?.body\n          ? { \"content-type\": OPENPOND_MODEL_PROJECT_MEDIA_TYPE }\n          : {}),\n        ...headersRecord(configuredHeaders),\n        ...headersRecord(init?.headers),\n      },\n    });\n    const body = await readBoundedJsonResponse(\n      response,\n      MODEL_PROJECT_API_RESPONSE_MAX_BYTES,\n      \"Model Project API response\",\n    );\n    if (!response.ok) {\n      const parsed = ModelProjectApiErrorSchema.safeParse(body);\n      if (parsed.success) {\n        throw new OpenPondModelProjectApiError(response.status, parsed.data);\n      }\n      throw new OpenPondProtocolError(\n        \"invalid_error_response\",\n        `Model Project request failed with HTTP ${response.status} and an invalid error envelope.`,\n      );\n    }\n    return body;\n  }\n\n  return {\n    async configurationCandidates() {\n      return z.object({ candidates: z.array(ModelProjectBaseModelCandidateSchema).max(1000) }).strict().parse(\n        await request(\"/v1/model-projects/configuration/candidates\", { headers: { accept: \"application/json\" } }),\n      ).candidates;\n    },\n    async checkConfiguration(value: ModelProjectSaveRequest) {\n      const parsed = parseModelProjectSaveRequest(value);\n      return ModelProjectConfigurationCheckSchema.parse(await request(\"/v1/model-projects/configuration/check\", {\n        method: \"POST\", headers: { accept: \"application/json\", \"content-type\": \"application/json\" }, body: JSON.stringify(parsed),\n      }));\n    },\n    async saveConfiguration(value: ModelProjectSaveRequest) {\n      const parsed = parseModelProjectSaveRequest(value);\n      return HostedModelProjectSummarySchema.parse(await request(\"/v1/model-projects/configuration/save\", {\n        method: \"POST\", headers: { accept: \"application/json\", \"content-type\": \"application/json\" }, body: JSON.stringify(parsed),\n      }));\n    },\n    async upsert(project: HostedModelProjectSync) {\n      assertCanonicalPayloadSize(\n        project,\n        MODEL_PROJECT_SYNC_MAX_BYTES,\n        \"Model Project sync\",\n      );\n      const parsed = HostedModelProjectSyncSchema.parse(project);\n      const body = await request(\n        `/v1/model-projects/${encodeURIComponent(parsed.portableProjectId)}`,\n        { method: \"PUT\", body: JSON.stringify(parsed) },\n      );\n      return HostedModelProjectSummarySchema.parse(\n        unwrapObject(body, \"project\"),\n      );\n    },\n    async list() {\n      const body = await request(\"/v1/model-projects\");\n      return z\n        .array(HostedModelProjectSummarySchema)\n        .parse(unwrapObject(body, \"projects\"));\n    },\n    async get(projectId: string) {\n      const body = await request(\n        `/v1/model-projects/${encodeURIComponent(IdSchema.parse(projectId))}`,\n      );\n      return HostedModelProjectDetailSchema.parse(body);\n    },\n  };\n}\n\nfunction unwrapObject(value: unknown, key: string): unknown {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) return value;\n  return key in value ? (value as Record<string, unknown>)[key] : value;\n}\n","import { z } from \"zod\";\n\nconst Id = z.string().trim().min(1).max(191);\nconst Hash = z.string().regex(/^[a-f0-9]{64}$/);\n\nexport const TrainingGpuSelectionSchema = z.discriminatedUnion(\"mode\", [\n  z.object({ mode: z.literal(\"automatic\"), objective: z.enum([\"balanced\", \"fast\", \"economical\"]), gpuCount: z.union([z.literal(1), z.literal(2)]).optional() }).strict(),\n  z.object({ mode: z.literal(\"manual\"), availabilityId: Id, gpuType: z.string().trim().min(1).max(256), gpuCount: z.union([z.literal(1), z.literal(2)]).optional() }).strict(),\n]);\n\n/** This token binds a reviewed workload and price, without reserving resources\n * or approving the estimate's recommended budget. */\nexport const TrainingEstimateReviewSchema = z.object({\n  estimateId: Id,\n  inputHash: Hash,\n  requestHash: Hash,\n  pricingVersion: Id,\n  expiresAt: z.string().datetime({ offset: true }),\n  token: z.string().min(1).max(8192),\n}).strict();\n\nexport type TrainingGpuSelection = z.infer<typeof TrainingGpuSelectionSchema>;\nexport type TrainingEstimateReview = z.infer<typeof TrainingEstimateReviewSchema>;\n\nexport const TrainingGpuCatalogSchema = z.object({\n  schemaVersion: z.literal(\"openpond.trainingGpuCatalog.v1\"),\n  observedAt: z.string().datetime({ offset: true }),\n  expiresAt: z.string().datetime({ offset: true }),\n  workerImageDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),\n  supportedLoraRanks: z.array(z.number().int().positive()),\n  pricingBasis: z.literal(\"accepted_compute_and_disk_hourly_before_credits\"),\n  offerings: z.array(z.object({\n    availabilityId: Id, gpuType: z.string().min(1).max(256), provider: Id,\n    region: z.string().min(1), dataCenterId: z.string().nullable(),\n    gpuCount: z.number().int().positive(), gpuMemoryGb: z.number().positive(),\n    stockStatus: z.enum([\"High\", \"Medium\", \"Low\"]),\n    computeHourlyUsd: z.number().nonnegative(), diskHourlyUsd: z.number().nonnegative(), totalHourlyUsd: z.number().nonnegative(),\n  }).strict()).max(1000),\n}).strict();\nexport type TrainingGpuCatalog = z.infer<typeof TrainingGpuCatalogSchema>;\n"],"mappings":"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","names":["z","z"]}

package/dist/{chunk-HYCHLMP7.js → chunk-DMN6EF3R.js}

@@ -1,6 +1,6 @@
 import {
   TasksetDraftWorkspaceSchema
-} from "./chunk-U4QIGSP5.js";
+} from "./chunk-4L556MYM.js";
 import {
   TasksetCatalogReleaseRefSchema
 } from "./chunk-Z252BNAZ.js";
@@ -178,4 +178,4 @@ export {
   ConnectedStartingAssetsReceiptSchema,
   verifyConnectedStartingAssetsReceipt
 };
-//# sourceMappingURL=chunk-HYCHLMP7.js.map
+//# sourceMappingURL=chunk-DMN6EF3R.js.map

package/dist/{chunk-QVLJFJBU.js → chunk-ESW25WSD.js}

@@ -1,13 +1,13 @@
 import {
   validateTasksetPackage
-} from "./chunk-RFKZSSLB.js";
+} from "./chunk-7WKCQ4V5.js";
 import {
   RunExperimentSchema
-} from "./chunk-UWM2ZPGS.js";
+} from "./chunk-7FYPFHCQ.js";
 import {
   ExperimentScoringRequestSchema,
   verifyExperimentScoringPass
-} from "./chunk-YP5DXGGC.js";
+} from "./chunk-GIEST52U.js";
 import {
   fetchConnectedJson
 } from "./chunk-O6FKHAWN.js";
@@ -18,13 +18,13 @@ import {
   ExperimentListQuerySchema,
   PrepareHarnessExperimentSchema,
   PreparedHarnessExperimentSchema
-} from "./chunk-WYR3MZHU.js";
+} from "./chunk-HDKP6KE2.js";
 import {
   ModelTasksetRunDetailsSchema,
   ModelTasksetRunRequestSchema,
   verifyHarnessExperimentManifest,
   verifyModelTasksetRunDetails
-} from "./chunk-EWRWGFKD.js";
+} from "./chunk-IIQENUOK.js";
 import {
   ImmutableReleaseRefSchema,
   contentHash
@@ -652,4 +652,4 @@ export {
   ProfileEvaluationDiscoveryRequestSchema,
   OpenPondProfileEvaluationDiscoveryClient
 };
-//# sourceMappingURL=chunk-QVLJFJBU.js.map
+//# sourceMappingURL=chunk-ESW25WSD.js.map

package/dist/chunk-EZME7DV4.js

@@ -0,0 +1,161 @@
+import {
+  createTrainingRequest
+} from "./chunk-GX6KMHW2.js";
+import {
+  OpenPondProtocolError
+} from "./chunk-B3ZHJ2KK.js";
+
+// src/training-hardware.ts
+import { z } from "zod";
+var Id = z.string().min(1).max(191);
+var Timestamp = z.string().datetime({ offset: true });
+var Text = z.string().min(1).max(512);
+var Counter = z.number().finite().min(0).max(Number.MAX_SAFE_INTEGER);
+var MissingMetric = z.object({
+  status: z.enum(["unavailable", "unsupported", "permissionDenied", "error"]),
+  reason: Text
+}).strict();
+var metric = (value) => z.union([z.object({ status: z.literal("available"), value }).strict(), MissingMetric]);
+var NumberMetric = metric(Counter);
+var PercentMetric = metric(z.number().finite().min(0).max(100));
+var StringMetric = metric(Text);
+var HardwareAvailabilitySchema = z.union([
+  z.object({ status: z.literal("available") }).strict(),
+  MissingMetric
+]);
+var HardwareGpuObservationSchema = z.object({
+  index: z.number().int().min(0).max(4294967295),
+  uuid: StringMetric,
+  name: StringMetric,
+  pciBusId: StringMetric,
+  memoryTotalBytes: NumberMetric,
+  memoryUsedBytes: NumberMetric,
+  utilizationPercent: PercentMetric,
+  memoryUtilizationPercent: PercentMetric,
+  temperatureCelsius: NumberMetric,
+  powerWatts: NumberMetric,
+  powerLimitWatts: NumberMetric,
+  graphicsClockMhz: NumberMetric,
+  memoryClockMhz: NumberMetric,
+  eccCorrectedErrors: NumberMetric,
+  eccUncorrectedErrors: NumberMetric
+}).strict();
+var HardwareObservationSchema = z.object({
+  schemaVersion: z.literal(1),
+  collectorVersion: Text,
+  sessionId: z.string().uuid(),
+  sequence: Counter.int().min(1),
+  observedAt: Timestamp,
+  monotonicMs: Counter.int(),
+  sampleIntervalMs: z.number().int().min(100).max(6e4),
+  scope: z.enum(["container", "host", "guest", "unknown"]),
+  cpu: z.object({
+    logicalCores: NumberMetric,
+    utilizationPercent: PercentMetric,
+    cgroupCpuLimitCores: NumberMetric,
+    cgroupUsageUsec: NumberMetric
+  }).strict(),
+  memory: z.object({
+    hostTotalBytes: NumberMetric,
+    hostAvailableBytes: NumberMetric,
+    cgroupLimitBytes: NumberMetric,
+    cgroupCurrentBytes: NumberMetric
+  }).strict(),
+  driverVersion: StringMetric,
+  gpus: z.array(HardwareGpuObservationSchema).max(32),
+  capabilities: z.object({
+    cpu: HardwareAvailabilitySchema,
+    memory: HardwareAvailabilitySchema,
+    nvml: HardwareAvailabilitySchema
+  }).strict()
+}).strict().superRefine((value, context) => {
+  const indices = /* @__PURE__ */ new Set();
+  const uuids = /* @__PURE__ */ new Set();
+  value.gpus.forEach((gpu, index) => {
+    if (indices.has(gpu.index) || gpu.uuid.status === "available" && uuids.has(gpu.uuid.value)) {
+      context.addIssue({
+        code: "custom",
+        path: ["gpus", index],
+        message: "GPU identity must be unique within an observation."
+      });
+    }
+    indices.add(gpu.index);
+    if (gpu.uuid.status === "available") uuids.add(gpu.uuid.value);
+  });
+});
+var HardwareFleetSnapshotSchema = z.object({
+  schemaVersion: z.literal(1),
+  teamId: Id,
+  observedAt: Timestamp,
+  nextCursor: Id.nullable(),
+  workers: z.array(
+    z.object({
+      workerId: Id,
+      provider: Id,
+      state: Id,
+      jobIds: z.array(Id).max(128),
+      receivedAt: Timestamp.nullable(),
+      observation: HardwareObservationSchema.nullable(),
+      freshness: z.enum(["missing", "fresh", "stale"])
+    }).strict()
+  ).max(50)
+}).strict().superRefine((value, context) => {
+  const workers = /* @__PURE__ */ new Set();
+  value.workers.forEach((worker, index) => {
+    if (workers.has(worker.workerId))
+      context.addIssue({
+        code: "custom",
+        path: ["workers", index, "workerId"],
+        message: "Duplicate worker identity."
+      });
+    workers.add(worker.workerId);
+    if (worker.observation === null !== (worker.receivedAt === null) || worker.observation === null !== (worker.freshness === "missing")) {
+      context.addIssue({
+        code: "custom",
+        path: ["workers", index],
+        message: "Observation, receive time and freshness must describe the same evidence."
+      });
+    }
+  });
+});
+function createTrainingHardwareClient(request) {
+  return {
+    async hardwareObservations(query) {
+      const teamId = Id.parse(query.teamId);
+      const params = new URLSearchParams();
+      if (query.workerId !== void 0) params.set("workerId", Id.parse(query.workerId));
+      if (query.jobId !== void 0) params.set("jobId", Id.parse(query.jobId));
+      if (query.cursor !== void 0) params.set("cursor", Id.parse(query.cursor));
+      const limit = z.number().int().min(1).max(50).parse(query.limit ?? 25);
+      params.set("limit", String(limit));
+      const suffix = params.size ? `?${params}` : "";
+      const snapshot = HardwareFleetSnapshotSchema.parse(
+        await request(`/v1/managed-rl/hardware-observations${suffix}`, {
+          headers: { "x-openpond-team-id": teamId }
+        })
+      );
+      if (snapshot.teamId !== teamId || snapshot.workers.length > limit || snapshot.workers.some(
+        (worker) => query.workerId !== void 0 && worker.workerId !== query.workerId || query.jobId !== void 0 && !worker.jobIds.includes(query.jobId) || query.cursor !== void 0 && worker.workerId <= query.cursor
+      ) || snapshot.nextCursor !== null && snapshot.nextCursor !== snapshot.workers.at(-1)?.workerId) {
+        throw new OpenPondProtocolError(
+          "hardware_observation_scope_mismatch",
+          "Hardware observations do not match the requested workspace, worker or job."
+        );
+      }
+      return snapshot;
+    }
+  };
+}
+function createHardwareObservationClient(input) {
+  return createTrainingHardwareClient(createTrainingRequest(input));
+}
+
+export {
+  HardwareAvailabilitySchema,
+  HardwareGpuObservationSchema,
+  HardwareObservationSchema,
+  HardwareFleetSnapshotSchema,
+  createTrainingHardwareClient,
+  createHardwareObservationClient
+};
+//# sourceMappingURL=chunk-EZME7DV4.js.map