openpond-sdk 0.3.3 → 0.5.0

package/dist/model-starter-catalog.js

@@ -1,469 +1,26 @@
-// src/model-starter-catalog.ts
-import { z as z6 } from "zod";
-
-// src/model-projects.ts
-import { z } from "zod";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-var IdSchema = z.string().trim().min(1).max(500);
-var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var TimestampSchema = z.string().datetime({ offset: true });
-var ModelProjectImmutableRefSchema = z.object({
-  id: IdSchema,
-  contentHash: HashSchema
-}).strict();
-var ModelProjectVersionedRefSchema = ModelProjectImmutableRefSchema.extend({
-  revision: z.number().int().positive()
-}).strict();
-var ModelProjectBaseModelSchema = z.object({
-  schemaVersion: z.literal("openpond.baseModelPreference.v1"),
-  modelId: IdSchema,
-  revision: z.string().trim().min(1).max(256).nullable(),
-  tokenizerRevision: z.string().trim().min(1).max(256).nullable(),
-  chatTemplateHash: z.string().trim().min(8).max(256).nullable(),
-  modelAssetId: IdSchema.nullable(),
-  source: z.enum(["managed", "local", "builtin"])
-}).strict();
-var ModelProjectTrainingMethodSchema = z.enum([
-  "sft",
-  "dpo",
-  "grpo",
-  "ppo",
-  "sdft",
-  "opd",
-  "opsd",
-  "sdpo"
-]);
-var ModelProjectRecipeDocumentSchema = z.object({
-  schemaVersion: z.string().regex(/^openpond\.[A-Za-z0-9]+Recipe\.v\d+$/),
-  method: ModelProjectTrainingMethodSchema,
-  parameterization: z.enum(["lora", "full"])
-}).catchall(z.unknown());
-var ModelProjectTrainingSetupSchema = z.object({
-  tasksetRef: ModelProjectVersionedRefSchema.nullable().default(null),
-  rewardBindingRef: ModelProjectVersionedRefSchema.nullable().optional(),
-  tasksetRelease: ModelProjectImmutableRefSchema.nullable().default(null),
-  harnessRelease: ModelProjectImmutableRefSchema.nullable().default(null),
-  baseModel: ModelProjectBaseModelSchema.nullable().default(null),
-  method: ModelProjectTrainingMethodSchema.nullable().default(null),
-  destinationId: IdSchema.nullable().default(null),
-  managedRolloutPlacement: z.enum(["local", "remote"]).default("remote"),
-  managedGpuPlacementObjective: z.enum(["fast", "balanced", "economical"]).default("balanced"),
-  managedGpuRequirement: z.enum(["any", "h100_hbm3"]).default("any"),
-  runPreset: z.enum(["small", "standard", "custom", "small_experiment"]).nullable().default(null),
-  recipe: ModelProjectRecipeDocumentSchema.nullable().default(null),
-  preferredMaximumSpendUsd: z.number().nonnegative().nullable().default(null),
-  preferredRetentionDays: z.number().int().nonnegative().nullable().default(null)
-}).strict();
-var HostedModelProjectTrainingSetupSchema = ModelProjectTrainingSetupSchema.omit({ managedGpuRequirement: true });
-var HostedModelProjectLinkSchema = z.object({
-  schemaVersion: z.literal("openpond.hostedModelProjectLink.v1"),
-  apiOrigin: z.string().url().refine((value) => new URL(value).origin === value, "Use a canonical API origin.").nullable().default(null),
-  teamId: IdSchema,
-  projectId: IdSchema,
-  portableProjectId: IdSchema,
-  revision: z.number().int().positive(),
-  etag: HashSchema,
-  syncedSourceRevision: z.number().int().positive(),
-  syncedAt: TimestampSchema,
-  tasksets: z.array(
-    z.object({
-      localTasksetId: IdSchema,
-      localTasksetHash: HashSchema.nullable().default(null),
-      releaseId: IdSchema,
-      releaseRevision: z.number().int().positive(),
-      releaseHash: HashSchema,
-      packageHash: HashSchema.nullable().default(null),
-      hostedTasksetId: IdSchema,
-      syncedAt: TimestampSchema
-    }).strict()
-  ).max(1e4).default([])
-}).strict();
-var ModelProjectTasksetSyncSchema = z.object({
-  localTasksetId: IdSchema,
-  releaseId: IdSchema,
-  releaseRevision: z.number().int().positive(),
-  releaseHash: HashSchema,
-  state: z.enum(["syncing", "synced", "sync_failed"]),
-  hostedTasksetId: IdSchema.nullable().default(null),
-  lastAttemptAt: TimestampSchema,
-  syncedAt: TimestampSchema.nullable().default(null),
-  lastError: z.string().trim().min(1).max(5e3).nullable().default(null)
-}).strict();
-var ModelProjectSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProject.v2"),
-  id: IdSchema,
-  profileId: IdSchema,
-  revision: z.number().int().positive().default(1),
-  name: z.string().trim().min(1).max(200),
-  objective: z.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: ModelProjectTrainingSetupSchema,
-  hosted: HostedModelProjectLinkSchema.nullable().default(null),
-  tasksetSyncs: z.array(ModelProjectTasksetSyncSchema).max(1e4).default([]),
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-}).strict();
-var ModelProjectEditableSchema = ModelProjectSchema.pick({
-  id: true,
-  profileId: true,
-  name: true,
-  objective: true,
-  defaultBaseModel: true,
-  defaultDestinationId: true,
-  trainingSetup: true
-});
-var ModelProjectSaveRequestSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProjectSave.v1"),
-  operationId: IdSchema,
-  expectedRevision: z.number().int().nonnegative(),
-  project: ModelProjectEditableSchema
-}).strict();
-var ModelProjectConfigurationCheckSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProjectConfigurationCheck.v1"),
-  configurationHash: HashSchema,
-  projectId: IdSchema,
-  expectedRevision: z.number().int().nonnegative(),
-  checkedAt: TimestampSchema,
-  canSave: z.boolean(),
-  deferred: z.array(z.enum(["base_model", "taskset"])).max(2),
-  findings: z.array(z.object({
-    code: IdSchema,
-    severity: z.enum(["error", "warning"]),
-    message: z.string().min(1).max(5e3),
-    field: z.string().min(1).max(500).nullable()
-  }).strict()).max(100)
-}).strict();
-var ModelProjectBaseModelCandidateSchema = z.object({
-  id: IdSchema,
-  name: z.string().min(1).max(500),
-  available: z.boolean(),
-  preference: ModelProjectBaseModelSchema
-}).strict();
-var HostedModelProjectSyncSchema = z.object({
-  schemaVersion: z.literal("openpond.hostedModelProjectSync.v2"),
-  portableProjectId: IdSchema,
-  name: z.string().trim().min(1).max(200),
-  objective: z.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: HostedModelProjectTrainingSetupSchema,
-  sourceRevision: z.number().int().positive(),
-  sourceUpdatedAt: TimestampSchema,
-  expectedEtag: HashSchema.nullable().default(null)
-}).strict();
-var HostedModelProjectSummarySchema = z.object({
-  id: IdSchema,
-  teamId: IdSchema,
-  portableProjectId: IdSchema,
-  name: z.string().trim().min(1).max(200),
-  objective: z.string().trim().max(5e3).nullable(),
-  defaultBaseModel: ModelProjectBaseModelSchema.nullable(),
-  defaultDestinationId: IdSchema.nullable(),
-  trainingSetup: HostedModelProjectTrainingSetupSchema,
-  sourceRevision: z.number().int().positive(),
-  sourceUpdatedAt: TimestampSchema,
-  revision: z.number().int().positive(),
-  etag: HashSchema,
-  createdAt: TimestampSchema,
-  updatedAt: TimestampSchema
-}).strict();
-var ModelProjectResourceSummarySchema = z.object({
-  kind: z.enum([
-    "taskset_release",
-    "harness_release",
-    "dataset_release",
-    "evidence_set",
-    "model_version",
-    "reward_model_version",
-    "evaluation_receipt"
-  ]),
-  ref: ModelProjectImmutableRefSchema,
-  role: z.string().trim().min(1).max(200).nullable().default(null),
-  updatedAt: TimestampSchema
-}).strict();
-var HostedModelProjectDetailSchema = z.object({
-  project: HostedModelProjectSummarySchema,
-  resources: z.array(ModelProjectResourceSummarySchema).max(1e4),
-  jobCount: z.number().int().nonnegative(),
-  latestJobIds: z.array(IdSchema).max(100)
-}).strict();
-var ModelProjectApiErrorSchema = z.object({
-  schemaVersion: z.literal("openpond.modelProjectApiError.v2"),
-  code: z.string().trim().min(1).max(200),
-  message: z.string().trim().min(1).max(5e3),
-  retryable: z.boolean().default(false),
-  requestId: z.string().trim().min(1).max(500).nullable().default(null),
-  details: z.record(z.string(), z.unknown()).default({})
-}).strict();
-
-// src/model-starters.ts
-import { z as z5 } from "zod";
-import { TasksetReleaseSchema as TasksetReleaseSchema2, assertTasksetRelease as assertTasksetRelease2 } from "@openpond/evals/tasksets";
-import { LearningTextAssetSchema as LearningTextAssetSchema2, TaskDefinitionSchema as TaskDefinitionSchema2, learningRef as learningRef3, sameLearningRef as sameLearningRef2, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
-import { RewardBindingSchema as RewardBindingSchema2, RewardReleaseSchema as RewardReleaseSchema2, compileBoundGraders as compileBoundGraders2 } from "@openpond/evals/rewards";
-import { assertBoundedTaskJson as assertBoundedTaskJson3, validateTaskValue as validateTaskValue2 } from "@openpond/evals/task-schema";
-
-// src/model-starter-execution.ts
-import { z as z2 } from "zod";
-import { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from "@openpond/evals";
-import { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from "@openpond/evals/javascript-environment";
-import { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset } from "@openpond/evals/learning";
-import { assertBoundedTaskJson as assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
-var HashSchema2 = z2.string().regex(/^[a-f0-9]{64}$/);
-var ModelStarterEnvironmentAttemptSchema = z2.object({
-  schemaVersion: z2.literal("openpond.javascriptEnvironmentAttempt.v1"),
-  taskId: z2.string(),
-  status: z2.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
-  output: z2.string().nullable(),
-  collected: z2.boolean(),
-  environmentCleanupComplete: z2.boolean(),
-  snapshot: z2.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema2, seed: z2.number().int(), initialStateHash: HashSchema2, finalStateHash: HashSchema2, state: z2.record(z2.string(), z2.unknown()), events: z2.array(z2.record(z2.string(), z2.unknown())) }).strict().nullable(),
-  messages: z2.array(z2.unknown()),
-  error: z2.string().nullable(),
-  contentHash: HashSchema2
-}).strict();
-var ModelStarterExecutionSchema = z2.object({
-  environment: EnvironmentReleaseSchema,
-  verifierSet: VerifierSetReleaseSchema,
-  javascript: JavaScriptEnvironmentDefinitionSchema
-}).strict();
-var ModelStarterToolFixtureScriptSchema = z2.object({
-  actions: z2.array(z2.object({ name: z2.string().min(1).max(64), arguments: z2.record(z2.string(), z2.unknown()) }).strict()).max(1e3)
-}).strict();
-function equal(left, right) {
-  return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;
-}
-function assertExecutionIntegrity(execution) {
-  assertJavaScriptEnvironmentDefinition(execution.javascript);
-  for (const resource of [execution.environment, execution.verifierSet]) {
-    const { contentHash, ...content } = resource;
-    if (sealLearningContent(content).contentHash !== contentHash) throw new Error(`Starter execution resource integrity failed: ${resource.id}.`);
-  }
-  if (!equal(execution.environment.metadata.javascriptEnvironment, learningRef(execution.javascript))) throw new Error("Starter execution resources differ from its declared task context.");
-}
-function validateModelStarterExecution(execution, taskset, assets) {
-  if (!execution) {
-    if (taskset.environment.entrypoint === "openpond.javascript-environment.v1") throw new Error("Starter JavaScript execution resources are missing.");
-    return;
-  }
-  const { environment, verifierSet, javascript } = execution;
-  assertExecutionIntegrity(execution);
-  if (!equal(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !equal(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !equal(environment.contract, taskset.environment) || !equal(verifierSet.graders, taskset.graders) || !equal(taskset.tools, javascript.tools) || !equal(environment.metadata.javascriptEnvironment, learningRef(javascript))) {
-    throw new Error("Starter execution resources differ from its declared task context.");
-  }
-  const contract = environment.contract;
-  if (contract.entrypoint !== "openpond.javascript-environment.v1" || contract.kind !== "agent" || !contract.stateful || !contract.deterministicSeeds || contract.networkPolicy !== "none" || new Set(contract.lifecycle).size !== 5 || taskset.capabilities.length || taskset.policy.connectedAppScopes.length) {
-    throw new Error("Starter JavaScript environment declares unsupported host capabilities.");
-  }
-  for (const reference of [javascript.module, environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) {
-    if (!reference) continue;
-    const asset = assets.find((asset2) => asset2.id === reference.id);
-    if (!asset) throw new Error(`Starter environment asset is missing: ${reference.id}.`);
-    verifyLearningTextAsset(asset, reference);
-  }
-  for (const task of taskset.tasks) {
-    const asset = assets.find((asset2) => asset2.id === task.privilegedContextRef);
-    if (!asset || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") {
-      throw new Error(`Starter private initial state is missing: ${task.id}.`);
-    }
-    const state = JSON.parse(verifyLearningTextAsset(asset, asset.asset));
-    if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error(`Starter initial state must be a JSON object: ${task.id}.`);
-    assertBoundedTaskJson2(state, javascript.maxStateBytes);
-  }
-}
-
-// src/model-taskset-derivation.ts
-import { z as z4 } from "zod";
-import { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease as verifyEnvironmentRelease2, verifyVerifierSetRelease as verifyVerifierSetRelease2 } from "@openpond/evals";
-import { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
-import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
-import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
-import { validateTaskValue } from "@openpond/evals/task-schema";
-
-// src/model-taskset-resources.ts
-import { z as z3 } from "zod";
-import { EnvironmentReleaseSchema as EnvironmentReleaseSchema2, VerifierSetReleaseSchema as VerifierSetReleaseSchema2, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
-import { createLearningTextAsset as createLearningTextAsset2, sealLearningContent as sealLearningContent2, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
-var ModelTasksetExecutionResourcesSchema = z3.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
-
-// src/model-taskset-derivation.ts
-var OwnerSchema = z4.object({ scopeId: z4.string().trim().min(1).max(500), modelId: z4.string().trim().min(1).max(500) }).strict();
-var ModelTasksetDerivationSchema = z4.object({
-  schemaVersion: z4.literal("openpond.modelTasksetDerivation.v1"),
-  owner: OwnerSchema,
-  root: ModelProjectVersionedRefSchema,
-  parent: ModelProjectVersionedRefSchema
-}).strict();
-var ModelTasksetPackageSchema = z4.object({
-  taskset: TasksetReleaseSchema,
-  taskDefinition: TaskDefinitionSchema,
-  rewardBinding: RewardBindingSchema,
-  rewards: z4.array(RewardReleaseSchema).min(1).max(100),
-  assets: z4.array(LearningTextAssetSchema).max(1e3),
-  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
-  execution: ModelStarterExecutionSchema.optional()
-}).strict();
-
-// src/model-starters.ts
-var IdSchema2 = z5.string().trim().min(1).max(500);
-var RefSchema = ModelProjectVersionedRefSchema;
-var ModelStarterContentSchema = z5.object({
-  schemaVersion: z5.literal("openpond.modelStarter.v1"),
-  id: IdSchema2,
-  revision: z5.number().int().positive(),
-  name: z5.string().trim().min(1).max(200),
-  description: z5.string().trim().min(1).max(2e3),
-  category: z5.enum(["extraction", "support", "operations", "knowledge", "coding", "writing", "classification"]),
-  taskset: RefSchema,
-  taskDefinition: RefSchema,
-  rewardBinding: RefSchema,
-  rewards: z5.array(RefSchema).min(1).max(100),
-  assets: z5.array(RefSchema).max(1e3),
-  previewTaskIds: z5.array(IdSchema2).min(1).max(8),
-  startingModel: ModelProjectBaseModelSchema,
-  supportedMethods: z5.array(ModelProjectTrainingMethodSchema).min(1).max(8),
-  defaultMethod: ModelProjectTrainingMethodSchema,
-  provenance: z5.object({ author: z5.string().min(1).max(200), license: z5.string().min(1).max(200), sourceDescription: z5.string().min(1).max(2e3) }).strict(),
-  // These are references to real results. Package publication does not create
-  // evidence, qualify a starter, or enable continuous learning.
-  evidence: z5.object({ verifierFixtures: RefSchema.nullable(), baseline: RefSchema.nullable(), training: RefSchema.nullable(), evaluation: RefSchema.nullable() }).strict()
-}).strict().superRefine((starter, context) => {
-  if (!starter.supportedMethods.includes(starter.defaultMethod)) context.addIssue({ code: "custom", path: ["defaultMethod"], message: "The default method must be supported by the package." });
-  for (const field of ["rewards", "assets"]) {
-    if (new Set(starter[field].map((ref) => ref.id)).size !== starter[field].length) context.addIssue({ code: "custom", path: [field], message: "Dependency identities must be unique." });
-  }
-  if (new Set(starter.previewTaskIds).size !== starter.previewTaskIds.length) context.addIssue({ code: "custom", path: ["previewTaskIds"], message: "Preview tasks must be unique." });
-});
-var ModelStarterSchema = ModelStarterContentSchema.safeExtend({ contentHash: z5.string().regex(/^[a-f0-9]{64}$/) });
-var ResolvedModelStarterSchema = z5.object({
-  starter: ModelStarterSchema,
-  taskset: TasksetReleaseSchema2,
-  taskDefinition: TaskDefinitionSchema2,
-  rewardBinding: RewardBindingSchema2,
-  rewards: z5.array(RewardReleaseSchema2).min(1).max(100),
-  assets: z5.array(LearningTextAssetSchema2).max(1e3),
-  execution: ModelStarterExecutionSchema.optional()
-}).strict();
-var ModelStarterPrivacyReviewSchema = z5.object({
-  schemaVersion: z5.literal("openpond.modelStarterPrivacyReview.v1"),
-  disposition: z5.literal("synthetic_only"),
-  reviewedBy: z5.string().trim().min(1).max(500),
-  reviewedAt: z5.iso.datetime(),
-  reviewedContentHash: z5.string().regex(/^[a-f0-9]{64}$/),
-  note: z5.string().trim().min(1).max(2e3)
-}).strict();
-function modelStarterPrivacyContentHash(value) {
-  const { contentHash: _starterHash, ...starter } = value.starter;
-  const { contentHash: _tasksetHash, ...taskset } = value.taskset;
-  const { contentHash: _referenceHash, ...tasksetRef } = starter.taskset;
-  const metadata = { ...taskset.metadata };
-  const authoring = metadata.starterAuthoring;
-  if (authoring && typeof authoring === "object" && !Array.isArray(authoring)) {
-    const { privacyReview: _review, ...content } = authoring;
-    metadata.starterAuthoring = content;
-  }
-  return sealLearningContent4({ ...value, starter: { ...starter, taskset: tasksetRef }, taskset: { ...taskset, metadata } }).contentHash;
-}
-var ModelStarterCreationIntentSchema = z5.object({
-  profileId: IdSchema2,
-  modelId: IdSchema2,
-  name: z5.string().trim().min(1).max(200),
-  starter: RefSchema,
-  startingModel: ModelProjectBaseModelSchema,
-  method: ModelProjectTrainingMethodSchema,
-  rewardBindingRef: RefSchema.nullable().optional()
-}).strict();
-var ModelStarterCreationRequestSchema = ModelStarterCreationIntentSchema.extend({
-  schemaVersion: z5.literal("openpond.modelStarterCreation.v1"),
-  operationId: IdSchema2
-}).strict();
-function validateResolvedModelStarter(value) {
-  assertBoundedTaskJson3(value, 16 * 1024 * 1024);
-  const resolved = ResolvedModelStarterSchema.parse(value);
-  const { starter, taskset, taskDefinition, rewardBinding, rewards, assets } = resolved;
-  const authoring = taskset.metadata.starterAuthoring;
-  if (authoring && typeof authoring === "object" && !Array.isArray(authoring) && "privacyReview" in authoring) {
-    const review = ModelStarterPrivacyReviewSchema.parse(authoring.privacyReview);
-    if (review.reviewedContentHash !== modelStarterPrivacyContentHash(resolved)) throw new Error("Starter privacy review differs from the published contents.");
-  }
-  const resources = [starter, taskset, taskDefinition, rewardBinding, ...rewards, ...assets];
-  for (const resource of resources) {
-    const { contentHash, ...content } = resource;
-    if (sealLearningContent4(content).contentHash !== contentHash) throw new Error(`Starter resource integrity failed: ${resource.id}.`);
-  }
-  assertTasksetRelease2(taskset);
-  validateModelStarterExecution(resolved.execution, taskset, assets);
-  function exact(expected, resource) {
-    if (!sameLearningRef2(expected, learningRef3(resource))) throw new Error(`Starter dependency mismatch: ${expected.id}.`);
-  }
-  exact(starter.taskset, taskset);
-  exact(starter.taskDefinition, taskDefinition);
-  exact(starter.rewardBinding, rewardBinding);
-  exact(taskDefinition.rewardBinding, rewardBinding);
-  if (rewardBinding.recipeRef) throw new Error("Starter binding recipes must be resolved into a standalone binding before publication.");
-  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
-  const execution = { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} };
-  if (sealLearningContent4(execution).contentHash !== sealLearningContent4(taskDefinition.execution).contentHash) throw new Error("Starter execution context differs from its task format.");
-  if (sealLearningContent4({ graders: taskset.graders }).contentHash !== sealLearningContent4({ graders: compileBoundGraders2(rewardBinding, rewards) }).contentHash) throw new Error("Starter executable graders differ from its Reward binding.");
-  for (const [references, values] of [[starter.rewards, rewards], [starter.assets, assets]]) {
-    if (references.length !== values.length || new Set(values.map((resource) => resource.id)).size !== values.length) throw new Error("Starter dependency inventory mismatch.");
-    for (const ref of references) {
-      const resource = values.find((value2) => value2.id === ref.id);
-      if (!resource) throw new Error(`Starter dependency is missing: ${ref.id}.`);
-      exact(ref, resource);
-    }
-  }
-  for (const source of rewardBinding.sources) {
-    const reward = rewards.find((reward2) => reward2.id === source.reward.id);
-    if (!reward) throw new Error(`Starter Reward is missing: ${source.reward.id}.`);
-    exact(source.reward, reward);
-  }
-  for (const reward of rewards) {
-    const implementation = reward.implementation;
-    const references = [
-      ...reward.assets,
-      ..."verifierRef" in implementation ? [implementation.verifierRef] : [],
-      ..."rubricRef" in implementation ? [implementation.rubricRef] : [],
-      ..."inputContract" in implementation ? [implementation.inputContract] : []
-    ];
-    for (const ref of references) {
-      const asset = assets.find((asset2) => asset2.id === ref.id);
-      if (!asset || sealLearningContent4(asset.asset).contentHash !== sealLearningContent4(ref).contentHash) throw new Error(`Starter Reward source is missing or changed: ${ref.id}.`);
-      if (ref.visibility === "policy") throw new Error(`Starter Reward source must remain private to its evaluator: ${ref.id}.`);
-    }
-  }
-  if (new Set(taskset.tasks.map((task) => task.id)).size !== taskset.tasks.length) throw new Error("Starter task identities must be unique.");
-  const inputSplits = /* @__PURE__ */ new Map();
-  for (const task of taskset.tasks) {
-    if (task.policyVisibleContext.instructions !== taskDefinition.instructions) throw new Error(`Starter task does not carry its declared model instructions: ${task.id}.`);
-    const inputHash = sealLearningContent4({ input: task.input, context: task.policyVisibleContext }).contentHash;
-    const priorSplit = inputSplits.get(inputHash);
-    if (priorSplit && priorSplit !== task.split) throw new Error("Starter policy input appears in multiple splits.");
-    inputSplits.set(inputHash, task.split);
-    if (!validateTaskValue2(taskDefinition.inputSchema, task.input).valid) throw new Error(`Starter task input does not match its format: ${task.id}.`);
-    if (task.expectedOutput !== null && !validateTaskValue2(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Starter expected output does not match its format: ${task.id}.`);
-  }
-  for (const id of starter.previewTaskIds) {
-    const task = taskset.tasks.find((task2) => task2.id === id);
-    if (!task || task.split === "frozen_eval") throw new Error(`Starter preview task is unavailable: ${id}.`);
-  }
-  return resolved;
-}
+import {
+  ModelStarterSchema,
+  validateResolvedModelStarter
+} from "./chunk-747CMU2Y.js";
+import "./chunk-65D4C7HP.js";
+import {
+  ModelProjectVersionedRefSchema
+} from "./chunk-5PRP457R.js";
 
 // src/model-starter-catalog.ts
-var ModelStarterCatalogQuerySchema = z6.object({
-  afterId: z6.string().trim().min(1).max(500).optional(),
-  limit: z6.number().int().min(1).max(100).default(30)
+import { z } from "zod";
+var ModelStarterCatalogQuerySchema = z.object({
+  afterId: z.string().trim().min(1).max(500).optional(),
+  limit: z.number().int().min(1).max(100).default(30)
 }).strict();
 var ModelStarterCatalogItemSchema = ModelStarterSchema.extend({
-  rewardSummary: z6.array(z6.object({ name: z6.string().min(1).max(500), kind: z6.enum(["custom_verifier", "model_judge", "human", "learned_model", "content", "schema", "artifact", "runtime_event", "state"]) }).strict()).max(100).optional()
+  rewardSummary: z.array(z.object({ name: z.string().min(1).max(500), kind: z.enum(["custom_verifier", "model_judge", "human", "learned_model", "content", "schema", "artifact", "runtime_event", "state"]) }).strict()).max(100).optional()
 });
-var ModelStarterCatalogPageSchema = z6.object({
-  items: z6.array(ModelStarterCatalogItemSchema).max(100),
-  nextCursor: z6.string().min(1).max(500).nullable()
+var ModelStarterCatalogPageSchema = z.object({
+  items: z.array(ModelStarterCatalogItemSchema).max(100),
+  nextCursor: z.string().min(1).max(500).nullable()
 }).strict();
-var ModelStarterCatalogErrorSchema = z6.object({ code: z6.string().min(1).max(200), message: z6.string().min(1).max(5e3) }).strict();
+var ModelStarterCatalogErrorSchema = z.object({ code: z.string().min(1).max(200), message: z.string().min(1).max(5e3) }).strict();
 var OpenPondModelStarterCatalogError = class extends Error {
   constructor(status, code, message) {
     super(message);