openpond-sdk 0.3.2 → 0.4.0

package/dist/model-starters.js

@@ -1,712 +1,35 @@
-// 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-projects.ts
-import { z } from "zod";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-
-// src/protocol.ts
-var OpenPondProtocolError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "OpenPondProtocolError";
-    this.code = code;
-  }
-};
-function canonicalJson(value) {
-  return JSON.stringify(normalizeCanonicalJson(value));
-}
-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 normalizeCanonicalJson(value) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new OpenPondProtocolError(
-        "non_json_value",
-        "Canonical JSON cannot contain a non-finite number."
-      );
-    }
-    return Object.is(value, -0) ? 0 : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => normalizeCanonicalJson(entry));
-  }
-  if (typeof value === "object") {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw new OpenPondProtocolError(
-        "non_json_value",
-        "Canonical JSON accepts only plain objects."
-      );
-    }
-    const result = {};
-    for (const key of Object.keys(value).sort()) {
-      const entry = value[key];
-      if (entry === void 0 || typeof entry === "function" || typeof entry === "symbol") {
-        throw new OpenPondProtocolError(
-          "non_json_value",
-          `Canonical JSON cannot contain ${typeof entry} at ${key}.`
-        );
-      }
-      result[key] = normalizeCanonicalJson(entry);
-    }
-    return result;
-  }
-  throw new OpenPondProtocolError(
-    "non_json_value",
-    `Canonical JSON cannot contain ${typeof value}.`
-  );
-}
-
-// src/model-projects.ts
-var IdSchema = 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-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();
-function verifyModelStarterEnvironmentAttempt(value, context) {
-  assertBoundedTaskJson2(value, 16777216);
-  const result = ModelStarterEnvironmentAttemptSchema.parse(value);
-  const { contentHash, ...content } = result;
-  if (sealLearningContent(content).contentHash !== contentHash || result.taskId !== context.taskId || result.snapshot && (!equal(result.snapshot.definition, context.javascript) || result.snapshot.inputHash !== sealLearningContent(context.input).contentHash || result.snapshot.seed !== context.seed || result.snapshot.finalStateHash !== sealLearningContent(result.snapshot.state).contentHash)) throw new Error("Starter environment attempt differs from its admitted task or recorded bytes.");
-  return result;
-}
-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 modelStarterExecutionAssetId(context) {
-  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Starter execution release references are missing.");
-  return `starter-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
-}
-function createModelStarterExecutionAsset(value) {
-  const execution = ModelStarterExecutionSchema.parse(value);
-  assertExecutionIntegrity(execution);
-  const id = modelStarterExecutionAssetId({ environmentRelease: { id: execution.environment.id, contentHash: execution.environment.contentHash }, verifierSetRelease: { id: execution.verifierSet.id, contentHash: execution.verifierSet.contentHash } });
-  const generated = createLearningTextAsset({ text: canonicalJson(execution), path: "environment/execution.json", mediaType: "application/json", visibility: "host_private" });
-  const { contentHash: _hash, ...content } = generated;
-  return sealLearningContent({ ...content, id, asset: { ...content.asset, id } });
-}
-function resolveModelStarterExecutionAsset(context, asset, assets) {
-  if (asset.id !== modelStarterExecutionAssetId(context) || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") throw new Error("Starter execution asset differs from its Taskset references.");
-  const execution = ModelStarterExecutionSchema.parse(JSON.parse(verifyLearningTextAsset(asset, asset.asset)));
-  validateModelStarterExecution(execution, context, assets);
-  return execution;
-}
-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();
-function modelTasksetExecutionResourcesAssetId(context) {
-  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Taskset execution references are missing.");
-  return `taskset-execution-${sealLearningContent2({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
-}
-function createModelTasksetExecutionResourcesAsset(value) {
-  const resources = ModelTasksetExecutionResourcesSchema.parse({ environment: value.environment, verifierSet: value.verifierSet });
-  assertIntegrity(resources);
-  const id = modelTasksetExecutionResourcesAssetId({ environmentRelease: { id: resources.environment.id, contentHash: resources.environment.contentHash }, verifierSetRelease: { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash } });
-  const { contentHash: _hash, ...asset } = createLearningTextAsset2({ text: canonicalJson(resources), path: "environment/resources.json", mediaType: "application/json", visibility: "host_private" });
-  return sealLearningContent2({ ...asset, id, asset: { ...asset.asset, id } });
-}
-function resolveModelTasksetExecutionResourcesAsset(context, asset) {
-  if (asset.id !== modelTasksetExecutionResourcesAssetId(context) || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") throw new Error("Taskset execution asset differs from its published references.");
-  const resources = ModelTasksetExecutionResourcesSchema.parse(JSON.parse(verifyLearningTextAsset2(asset, asset.asset)));
-  assertIntegrity(resources);
-  if (asset.id !== createModelTasksetExecutionResourcesAsset(resources).id || canonicalJson(context.environment) !== canonicalJson(resources.environment.contract) || canonicalJson(context.graders) !== canonicalJson(resources.verifierSet.graders)) throw new Error("Taskset differs from its execution resources.");
-  return resources;
-}
-function assertIntegrity(resources) {
-  if (!verifyEnvironmentRelease(resources.environment) || !verifyVerifierSetRelease(resources.verifierSet)) throw new Error("Taskset execution resource integrity failed.");
-}
-
-// 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();
-var same = (left, right) => sealLearningContent3({ value: left }).contentHash === sealLearningContent3({ value: right }).contentHash;
-var identity = (owner, root) => `model-taskset-${sealLearningContent3({ owner, root }).contentHash}`;
-function deriveModelTaskset(input) {
-  const owner = OwnerSchema.parse(input.owner);
-  const source = validateModelTasksetPackage(input.source);
-  const previous = source.taskset.metadata.modelTasksetDerivation === void 0 ? null : ModelTasksetDerivationSchema.parse(source.taskset.metadata.modelTasksetDerivation);
-  if (previous && source.taskset.id !== identity(previous.owner, previous.root)) throw new Error("Derived Taskset identity differs from its ownership lineage.");
-  const owned = previous && same(previous.owner, owner);
-  const root = owned ? previous.root : learningRef2(source.taskset);
-  const id = owned ? source.taskset.id : identity(owner, root);
-  const revision = owned ? source.taskset.revision + 1 : 1;
-  const rewardBinding = RewardBindingSchema.parse(input.rewardBinding);
-  const rewards = input.rewards.map((reward) => RewardReleaseSchema.parse(reward));
-  const graders = compileBoundGraders(rewardBinding, rewards);
-  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
-  const policy = { ...source.taskset.policy, hiddenGraderRefs: graders.filter((grader) => grader.privileged).map((grader) => grader.id) };
-  const previousResources = source.executionResources ?? source.execution;
-  const environment = previousResources?.environment ?? createEnvironmentRelease({
-    schemaVersion: "openpond.environmentRelease.v1",
-    id: `${id}-environment`,
-    revision: 1,
-    contract: source.taskset.environment,
-    actionSchemaRef: null,
-    observationSchemaRef: null,
-    stateSchemaRef: null,
-    artifactCollection: { maxArtifacts: 1e5, maxTotalBytes: 25e7 },
-    adapterConformanceHashes: {},
-    metadata: {}
-  });
-  const verifierSet = createVerifierSetRelease({
-    schemaVersion: "openpond.verifierSetRelease.v1",
-    id: `${id}-verifiers`,
-    revision,
-    graders,
-    isolation: previousResources?.verifierSet.isolation ?? { processBoundary: "isolated_process", networkPolicy: "none", defaultTimeoutMs: Math.min(source.taskset.environment.defaultTimeoutMs, 3e5) },
-    calibrationReceiptRefs: [],
-    metadata: previousResources ? { sourceVerifierSet: learningRef2(previousResources.verifierSet) } : {}
-  });
-  const executionResources = { environment, verifierSet };
-  const execution = source.execution ? { ...source.execution, verifierSet } : void 0;
-  const { contentHash: _taskHash, ...taskContent } = source.taskset;
-  const { contentHash: _definitionHash, ...definitionContent } = source.taskDefinition;
-  const taskExecution = { ...definitionContent.execution, policy, environmentRelease: { id: environment.id, contentHash: environment.contentHash }, verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash } };
-  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent3({ ...definitionContent, id: `${id}-definition`, revision, rewardBinding: learningRef2(rewardBinding), execution: taskExecution }));
-  const authoring = source.taskset.metadata.starterAuthoring;
-  const graderFixtures = authoring && typeof authoring === "object" && !Array.isArray(authoring) && "graderFixtures" in authoring ? authoring.graderFixtures : void 0;
-  const taskset = TasksetReleaseSchema.parse(sealLearningContent3({
-    ...taskContent,
-    ...taskExecution,
-    id,
-    revision,
-    graders,
-    metadata: {
-      starter: { taskDefinition: learningRef2(taskDefinition), rewardBinding: learningRef2(rewardBinding) },
-      rewardExecution: { binding: rewardBinding, rewards },
-      ...graderFixtures === void 0 ? {} : { starterAuthoring: { graderFixtures } },
-      modelTasksetDerivation: { schemaVersion: "openpond.modelTasksetDerivation.v1", owner, root, parent: learningRef2(source.taskset) }
-    }
-  }));
-  return validateModelTasksetPackage({ taskset, taskDefinition, rewardBinding, rewards, assets: input.assets, executionResources, ...execution ? { execution } : {} });
-}
-function validateModelTasksetPackage(value) {
-  const result = ModelTasksetPackageSchema.parse(value);
-  const { taskset, taskDefinition, rewardBinding, rewards, assets, execution } = result;
-  for (const resource of [taskset, taskDefinition, rewardBinding, ...rewards, ...assets]) assertLearningContentHash(resource);
-  assertTasksetRelease(taskset);
-  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
-  if (!sameLearningRef(taskDefinition.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset definition differs from its Reward binding.");
-  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
-  if (!same(taskDefinition.execution, { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} })) throw new Error("Taskset definition differs from its execution resources.");
-  if (!same(taskset.graders, compileBoundGraders(rewardBinding, rewards))) throw new Error("Taskset graders differ from its Reward binding.");
-  if (taskset.metadata.starter !== void 0) {
-    const metadata = z4.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);
-    if (!sameLearningRef(metadata.taskDefinition, learningRef2(taskDefinition)) || !sameLearningRef(metadata.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset metadata differs from its immutable grading resources.");
-  }
-  if (taskset.metadata.rewardExecution !== void 0 && !same(taskset.metadata.rewardExecution, { binding: rewardBinding, rewards })) throw new Error("Taskset embedded Rewards differ from its immutable grading resources.");
-  if (taskset.metadata.rewardBinding !== void 0 && !sameLearningRef(ModelProjectVersionedRefSchema.parse(taskset.metadata.rewardBinding), learningRef2(rewardBinding))) throw new Error("Taskset Reward reference differs from its immutable grading resources.");
-  const resources = result.executionResources ?? execution;
-  if (taskset.environmentRelease && !resources) throw new Error("Deriving a Taskset requires its pinned execution resources.");
-  if (resources && (!verifyEnvironmentRelease2(resources.environment) || !verifyVerifierSetRelease2(resources.verifierSet) || !same(taskset.environmentRelease, { id: resources.environment.id, contentHash: resources.environment.contentHash }) || !same(taskset.verifierSetRelease, { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash }) || !same(taskset.environment, resources.environment.contract) || !same(taskset.graders, resources.verifierSet.graders))) throw new Error("Taskset differs from its pinned execution resources.");
-  validateModelStarterExecution(execution, taskset, assets);
-  if (new Set(assets.map((asset) => asset.id)).size !== assets.length) throw new Error("Taskset asset identities must be unique.");
-  for (const asset of assets) verifyLearningTextAsset3(asset, asset.asset);
-  for (const reference of resources ? [resources.environment.actionSchemaRef, resources.environment.observationSchemaRef, resources.environment.stateSchemaRef] : []) {
-    if (!reference) continue;
-    const asset = assets.find((asset2) => asset2.id === reference.id);
-    if (!asset) throw new Error(`Taskset environment asset is missing: ${reference.id}.`);
-    verifyLearningTextAsset3(asset, reference);
-  }
-  for (const task of taskset.tasks) {
-    if (task.policyVisibleContext.instructions !== taskDefinition.instructions || !validateTaskValue(taskDefinition.inputSchema, task.input).valid || task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Taskset task differs from its declared format: ${task.id}.`);
-    if (task.privilegedContextRef && !assets.some((asset) => asset.id === task.privilegedContextRef && asset.asset.visibility === "host_private")) throw new Error(`Taskset private context is missing: ${task.id}.`);
-  }
-  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 reference of references) {
-      const asset = assets.find((asset2) => asset2.id === reference.id);
-      if (!asset || reference.visibility === "policy") throw new Error(`Taskset Reward requires its private asset: ${reference.id}.`);
-      verifyLearningTextAsset3(asset, reference);
-    }
-  }
-  return result;
-}
-
-// 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 parseModelStarterCreationRequest(value) {
-  assertBoundedTaskJson3(value, 64 * 1024);
-  return ModelStarterCreationRequestSchema.parse(value);
-}
-async function createModelStarterCreationRequest(value) {
-  assertBoundedTaskJson3(value, 64 * 1024);
-  const intent = ModelStarterCreationIntentSchema.parse(value);
-  return parseModelStarterCreationRequest({
-    ...intent,
-    schemaVersion: "openpond.modelStarterCreation.v1",
-    operationId: `model-starter:${await canonicalSha256(intent)}`
-  });
-}
-function validateModelStarterCreation(value, packageValue) {
-  const request = parseModelStarterCreationRequest(value);
-  const resolved = validateResolvedModelStarter(packageValue);
-  if (!sameLearningRef2(request.starter, learningRef3(resolved.starter))) throw new Error("Starter creation references a different package revision.");
-  if (!resolved.starter.supportedMethods.includes(request.method)) throw new Error("The selected training method is not supported by this starter.");
-  return { request, resolved };
-}
-function previewModelStarter(value) {
-  const { starter, taskset, taskDefinition, rewardBinding, rewards } = validateResolvedModelStarter(value);
-  return {
-    starter,
-    inputSchema: taskDefinition.inputSchema,
-    outputSchema: taskDefinition.outputSchema,
-    reward: {
-      name: rewardBinding.name,
-      description: rewardBinding.description,
-      checks: rewardBinding.sources.map((source) => {
-        const reward = rewards.find((reward2) => sameLearningRef2(source.reward, learningRef3(reward2)));
-        return { name: reward.name, description: reward.description, kind: reward.implementation.kind, role: source.role, weight: source.weight, required: source.required, hardGate: source.hardGate };
-      })
-    },
-    tasks: starter.previewTaskIds.map((id) => {
-      const task = taskset.tasks.find((task2) => task2.id === id);
-      return { id: task.id, input: task.input, policyVisibleContext: task.policyVisibleContext };
-    }),
-    counts: {
-      train: taskset.tasks.filter((task) => task.split === "train").length,
-      validation: taskset.tasks.filter((task) => task.split === "validation").length,
-      frozenEvaluation: taskset.tasks.filter((task) => task.split === "frozen_eval").length
-    }
-  };
-}
-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 {
+  ModelStarterContentSchema,
+  ModelStarterCreationIntentSchema,
+  ModelStarterCreationRequestSchema,
+  ModelStarterPrivacyReviewSchema,
+  ModelStarterSchema,
+  ResolvedModelStarterSchema,
+  createModelStarterCreationRequest,
+  modelStarterPrivacyContentHash,
+  parseModelStarterCreationRequest,
+  previewModelStarter,
+  validateModelStarterCreation,
+  validateResolvedModelStarter
+} from "./chunk-747CMU2Y.js";
+import {
+  ModelStarterEnvironmentAttemptSchema,
+  ModelStarterExecutionSchema,
+  ModelStarterToolFixtureScriptSchema,
+  ModelTasksetDerivationSchema,
+  ModelTasksetExecutionResourcesSchema,
+  ModelTasksetPackageSchema,
+  createModelStarterExecutionAsset,
+  createModelTasksetExecutionResourcesAsset,
+  deriveModelTaskset,
+  modelStarterExecutionAssetId,
+  modelTasksetExecutionResourcesAssetId,
+  resolveModelStarterExecutionAsset,
+  resolveModelTasksetExecutionResourcesAsset,
+  validateModelTasksetPackage,
+  verifyModelStarterEnvironmentAttempt
+} from "./chunk-65D4C7HP.js";
+import "./chunk-5PRP457R.js";
 export {
   ModelStarterContentSchema,
   ModelStarterCreationIntentSchema,