openpond-sdk 0.11.0 → 0.11.2

package/dist/chunk-JA3KFK3U.js

@@ -1,580 +0,0 @@
-import {
-  ModelTasksetAuthoringSchema
-} from "./chunk-2U54EOXJ.js";
-import {
-  ModelProjectVersionedRefSchema,
-  canonicalJson
-} from "./chunk-TCHAWJMB.js";
-import {
-  ImmutableAssetRefSchema,
-  contentHash,
-  sha256
-} from "./chunk-QUOW6URQ.js";
-
-// src/model-starter-execution.ts
-import { z } 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 } from "@openpond/evals/task-schema";
-import {
-  NativeHarnessExperimentAttemptSchema,
-  verifyNativeHarnessExperimentAttempt
-} from "@openpond/evals/experiments";
-var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var ModelStarterEnvironmentAttemptSchema = /* @__PURE__ */ (() => z.object({
-  schemaVersion: z.literal("openpond.javascriptEnvironmentAttempt.v1"),
-  taskId: z.string(),
-  status: z.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
-  output: z.string().nullable(),
-  collected: z.boolean(),
-  environmentCleanupComplete: z.boolean(),
-  snapshot: z.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema, seed: z.number().int(), initialStateHash: HashSchema, finalStateHash: HashSchema, state: z.record(z.string(), z.unknown()), events: z.array(z.record(z.string(), z.unknown())) }).strict().nullable(),
-  messages: z.array(z.unknown()),
-  error: z.string().nullable(),
-  contentHash: HashSchema
-}).strict())();
-function verifyModelStarterEnvironmentAttempt(value, context) {
-  assertBoundedTaskJson(value, 16777216);
-  const result = ModelStarterEnvironmentAttemptSchema.parse(value);
-  const { contentHash: contentHash2, ...content } = result;
-  if (sealLearningContent(content).contentHash !== contentHash2 || 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 = z.object({
-  environment: EnvironmentReleaseSchema,
-  verifierSet: VerifierSetReleaseSchema,
-  javascript: JavaScriptEnvironmentDefinitionSchema
-}).strict();
-var ModelStarterToolFixtureScriptSchema = z.object({
-  actions: z.array(z.object({ name: z.string().min(1).max(64), arguments: z.record(z.string(), z.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: contentHash2, ...content } = resource;
-    if (sealLearningContent(content).contentHash !== contentHash2) 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}.`);
-    assertBoundedTaskJson(state, javascript.maxStateBytes);
-  }
-}
-
-// src/model-taskset-resources.ts
-import { z as z2 } 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 = z2.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
-import { z as z3 } 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";
-var OwnerSchema = z3.object({ scopeId: z3.string().trim().min(1).max(500), modelId: z3.string().trim().min(1).max(500) }).strict();
-var ModelTasksetDerivationSchema = z3.object({
-  schemaVersion: z3.literal("openpond.modelTasksetDerivation.v1"),
-  owner: OwnerSchema,
-  root: ModelProjectVersionedRefSchema,
-  parent: ModelProjectVersionedRefSchema
-}).strict();
-var ModelTasksetPackageSchema = z3.object({
-  taskset: TasksetReleaseSchema,
-  taskDefinition: TaskDefinitionSchema,
-  rewardBinding: RewardBindingSchema,
-  rewards: z3.array(RewardReleaseSchema).min(1).max(100),
-  assets: z3.array(LearningTextAssetSchema).max(1e3),
-  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
-  execution: ModelStarterExecutionSchema.optional(),
-  instructionMode: z3.literal("per_task").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) {
-  return compileModelTasksetReward({ ...input, source: validateModelTasksetPackage(input.source) });
-}
-function compileModelTasksetReward(input) {
-  const owner = OwnerSchema.parse(input.owner);
-  const source = input.source;
-  const edited = input.edits ?? 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 = { ...edited.taskset.policy, hiddenGraderRefs: graders.filter((grader) => grader.privileged).map((grader) => grader.id) };
-  const previousResources = edited.executionResources ?? edited.execution;
-  const environment = previousResources?.environment ?? createEnvironmentRelease({
-    schemaVersion: "openpond.environmentRelease.v1",
-    id: `${id}-environment`,
-    revision: 1,
-    contract: edited.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(edited.taskset.environment.defaultTimeoutMs, 3e5) },
-    calibrationReceiptRefs: [],
-    metadata: previousResources ? { sourceVerifierSet: learningRef2(previousResources.verifierSet) } : {}
-  });
-  const executionResources = { environment, verifierSet };
-  const execution = edited.execution ? { ...edited.execution, verifierSet } : void 0;
-  const { contentHash: _taskHash, ...taskContent } = edited.taskset;
-  const { contentHash: _definitionHash, ...definitionContent } = edited.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 ?? source.taskset.metadata.ordinaryAuthoring;
-  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 } },
-      ...edited.taskset.metadata.environmentResources === void 0 ? {} : { environmentResources: edited.taskset.metadata.environmentResources },
-      modelTasksetDerivation: { schemaVersion: "openpond.modelTasksetDerivation.v1", owner, root, parent: learningRef2(source.taskset) }
-    }
-  }));
-  return validateModelTasksetPackage({ taskset, taskDefinition, rewardBinding, rewards, assets: input.assets, executionResources, ...execution ? { execution } : {}, ...source.instructionMode ? { instructionMode: source.instructionMode } : {} });
-}
-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 = z3.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 (taskDefinition.requiredOutputs && !same(task.requiredOutputs, taskDefinition.requiredOutputs)) throw new Error(`Taskset outputs differ from its reviewed definition: ${task.id}.`);
-    if (result.instructionMode !== "per_task" && 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/taskset-package-learning.ts
-import { z as z4 } from "zod";
-import {
-  TaskBatchSchema,
-  TaskEvidenceSchema,
-  TaskAdmissionDecisionSchema,
-  LearningSourceSchema,
-  LearningTextAssetSchema as LearningTextAssetSchema2,
-  assertLearningContentHash as assertLearningContentHash2,
-  compileTaskBatch,
-  learningRef as learningRef3,
-  sameLearningRef as sameLearningRef2,
-  taskBatchPackageMetadata,
-  verifyLearningTextAsset as verifyLearningTextAsset4
-} from "@openpond/evals/learning";
-var TasksetPackageLearningResourcesSchema = z4.object({
-  batch: TaskBatchSchema,
-  evidence: z4.array(TaskEvidenceSchema).min(1).max(1e4),
-  decisions: z4.array(TaskAdmissionDecisionSchema).min(1).max(1e4),
-  sources: z4.array(LearningSourceSchema).min(1).max(1e4),
-  assets: z4.array(LearningTextAssetSchema2).max(1e3)
-}).strict();
-function learningPackageContextFiles(resources) {
-  return resources.evidence.filter((evidence) => evidence.submission.evaluatorContext !== null).map((evidence) => {
-    const text = canonicalJson(evidence.submission.evaluatorContext);
-    const bytes = new TextEncoder().encode(text);
-    return {
-      asset: {
-        id: `task-evidence:${evidence.contentHash}`,
-        path: `learning/context/${evidence.contentHash}.json`,
-        contentHash: sha256(bytes),
-        sizeBytes: bytes.byteLength,
-        mediaType: "application/json",
-        visibility: "host_private"
-      },
-      base64: btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""))
-    };
-  });
-}
-function validateTasksetLearningResources(taskset, input) {
-  const resources = TasksetPackageLearningResourcesSchema.parse(input);
-  const metadata = taskBatchPackageMetadata(taskset);
-  if (!sameLearningRef2(learningRef3(resources.batch), metadata.batch)) throw new Error("Taskset learning batch differs from its admission metadata.");
-  for (const collection of [resources.evidence, resources.decisions, resources.sources, resources.assets]) {
-    const identities = /* @__PURE__ */ new Set();
-    for (const resource of collection) {
-      assertLearningContentHash2(resource);
-      const key = `${resource.id}:${resource.revision}`;
-      if (identities.has(key)) throw new Error("Taskset learning resource identities must be unique.");
-      identities.add(key);
-    }
-  }
-  if (resources.evidence.length !== resources.batch.examples.length || resources.decisions.length !== resources.batch.examples.length) throw new Error("Taskset learning snapshots must match the admitted batch inventory.");
-  for (const evidence of resources.evidence) {
-    const source = resources.sources.find((source2) => sameLearningRef2(learningRef3(source2), evidence.source));
-    if (!source || !sameLearningRef2(source.taskDefinition, learningRef3(metadata.definition))) throw new Error("Taskset evidence source differs from its task definition.");
-  }
-  if (resources.sources.some((source) => !resources.evidence.some((evidence) => sameLearningRef2(evidence.source, learningRef3(source))))) throw new Error("Taskset package includes an unrelated learning source.");
-  const rewardAssets = metadata.rewards.flatMap((reward) => [
-    ...reward.assets,
-    ...reward.implementation.kind === "custom_verifier" ? [reward.implementation.verifierRef] : reward.implementation.kind === "model_judge" || reward.implementation.kind === "human" ? [reward.implementation.rubricRef] : [],
-    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
-  ]);
-  for (const ref of rewardAssets) {
-    const asset = resources.assets.find((asset2) => asset2.id === ref.id);
-    if (!asset) throw new Error("Taskset learning Reward asset is missing.");
-    verifyLearningTextAsset4(asset, ref);
-  }
-  if (resources.assets.some((asset) => !rewardAssets.some((ref) => ref.id === asset.id))) throw new Error("Taskset package includes an unrelated learning asset.");
-  const compiled = compileTaskBatch({
-    batch: resources.batch,
-    definition: metadata.definition,
-    binding: metadata.binding,
-    rewards: metadata.rewards,
-    evidence: resources.evidence,
-    decisions: resources.decisions
-  });
-  const compiledMetadata = taskBatchPackageMetadata(compiled);
-  if (contentHash(compiledMetadata) !== contentHash(metadata)) throw new Error("Taskset admission metadata differs from its reviewed snapshots.");
-  const execution = (release) => ({ policy: release.policy, environment: release.environment, tools: release.tools });
-  if (contentHash(execution(compiled)) !== contentHash(execution(taskset))) throw new Error("Taskset execution differs from its reviewed task definition.");
-  const taskContent = (task) => ({
-    id: task.id,
-    clusterKey: task.clusterKey,
-    split: task.split,
-    input: task.input,
-    expectedOutput: task.expectedOutput,
-    policyVisibleContext: task.policyVisibleContext,
-    privilegedContextRef: task.privilegedContextRef,
-    artifactRefs: task.artifactRefs,
-    requiredOutputs: task.requiredOutputs ?? [],
-    tags: task.tags
-  });
-  if (contentHash(compiled.tasks.map(taskContent)) !== contentHash(taskset.tasks.map(taskContent))) throw new Error("Taskset rows differ from their reviewed evidence.");
-  return resources;
-}
-
-// src/taskset-package-files.ts
-import { z as z5 } from "zod";
-var MAX_TASKSET_PACKAGE_BYTES = 64 * 1024 * 1024;
-var TasksetPackageFileSchema = z5.object({
-  asset: ImmutableAssetRefSchema,
-  base64: z5.string().max(Math.ceil(MAX_TASKSET_PACKAGE_BYTES / 3) * 4)
-}).strict();
-function decodeTasksetPackageFile(value) {
-  const file = TasksetPackageFileSchema.parse(value);
-  const raw = atob(file.base64);
-  if (btoa(raw) !== file.base64) throw new Error(`Taskset asset ${file.asset.id} has noncanonical base64.`);
-  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
-  if (bytes.byteLength !== file.asset.sizeBytes || sha256(bytes) !== file.asset.contentHash) throw new Error(`Taskset asset ${file.asset.id} differs from its immutable bytes.`);
-  return bytes;
-}
-
-// src/taskset-package-execution.ts
-import { LearningTextAssetSchema as LearningTextAssetSchema3, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
-function resolveTasksetPackageExecution(input) {
-  if (input.taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return null;
-  const byId = new Map(input.files.map((file) => [file.asset.id, file]));
-  const read = (id) => {
-    const file = byId.get(id);
-    if (!file) throw new Error(`Taskset environment asset is missing: ${id}.`);
-    if (file.asset.sizeBytes > 524288) throw new Error("Taskset environment source exceeds the authored asset limit.");
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-    return LearningTextAssetSchema3.parse(sealLearningContent4({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text }));
-  };
-  let execution;
-  if (input.modelResources) {
-    if (!input.modelResources.execution) throw new Error("Bound Taskset JavaScript execution resources are missing.");
-    execution = ModelStarterExecutionSchema.parse(input.modelResources.execution);
-  } else {
-    const declaration = read(modelStarterExecutionAssetId(input.taskset));
-    if (declaration.asset.visibility !== "host_private" || declaration.asset.mediaType !== "application/json" || declaration.asset.path !== "environment/execution.json") throw new Error("Taskset execution declaration must be private JSON at environment/execution.json.");
-    execution = ModelStarterExecutionSchema.parse(JSON.parse(declaration.text));
-  }
-  const ids = /* @__PURE__ */ new Set([
-    execution.javascript.module.id,
-    ...[execution.environment.actionSchemaRef, execution.environment.observationSchemaRef, execution.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : []),
-    ...input.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : [])
-  ]);
-  const assets = [...ids].map(read);
-  validateModelStarterExecution(execution, input.taskset, assets);
-  return { execution, assets };
-}
-function createTasksetPackageExecutionFile(execution) {
-  const asset = createModelStarterExecutionAsset(execution);
-  const bytes = new TextEncoder().encode(asset.text);
-  let raw = "";
-  for (const byte of bytes) raw += String.fromCharCode(byte);
-  return { asset: asset.asset, base64: btoa(raw) };
-}
-
-// src/taskset-package-contracts.ts
-import { z as z6 } from "zod";
-import { EnvironmentReleaseSchema as EnvironmentReleaseSchema3, VerifierSetReleaseSchema as VerifierSetReleaseSchema3, verifyEnvironmentRelease as verifyEnvironmentRelease3, verifyVerifierSetRelease as verifyVerifierSetRelease3 } from "@openpond/evals";
-import { assertTasksetRelease as assertTasksetRelease2, TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
-import { assertBoundedTaskJson as assertBoundedTaskJson2 } from "@openpond/evals/task-schema";
-import { taskBatchPackageMetadata as taskBatchPackageMetadata2 } from "@openpond/evals/learning";
-
-// src/model-taskset-authoring-lineage.ts
-import { sameLearningRef as sameLearningRef3 } from "@openpond/evals/learning";
-function modelAuthoredTasksetId(lineage) {
-  return `model-authored-taskset-${contentHash({ owner: lineage.owner, root: lineage.root })}`;
-}
-function assertModelTasksetAuthoring(taskset) {
-  if (taskset.metadata.modelTasksetAuthoring === void 0) return null;
-  const lineage = ModelTasksetAuthoringSchema.parse(taskset.metadata.modelTasksetAuthoring);
-  if (taskset.id !== modelAuthoredTasksetId(lineage) || (taskset.revision === 1 ? !sameLearningRef3(lineage.parent, lineage.root) : lineage.parent.id !== taskset.id || lineage.parent.revision !== taskset.revision - 1)) {
-    throw new Error("Authored Taskset revision differs from its ownership lineage.");
-  }
-  return lineage;
-}
-
-// src/taskset-package-contracts.ts
-var BoundModelResourcesSchema = ModelTasksetPackageSchema.omit({ taskset: true, executionResources: true });
-var TasksetPackageContentSchema = z6.object({
-  schemaVersion: z6.literal("openpond.tasksetPackage.v1"),
-  taskset: TasksetReleaseSchema2,
-  environment: EnvironmentReleaseSchema3,
-  verifierSet: VerifierSetReleaseSchema3,
-  files: z6.array(TasksetPackageFileSchema).max(1e4),
-  modelResources: BoundModelResourcesSchema.optional(),
-  learningResources: TasksetPackageLearningResourcesSchema.optional()
-}).strict();
-var TasksetPackageSchema = TasksetPackageContentSchema.extend({ contentHash: z6.string().regex(/^[a-f0-9]{64}$/) }).strict();
-function tasksetPackageRewardBinding(value) {
-  return value.learningResources ? taskBatchPackageMetadata2(value.taskset).binding : value.modelResources?.rewardBinding ?? null;
-}
-function resolveTasksetPackageInstructions(value) {
-  if (value.learningResources) return taskBatchPackageMetadata2(value.taskset).definition.instructions;
-  if (value.modelResources) return value.modelResources.taskDefinition.instructions;
-  const authoring = z6.object({ instructions: z6.string().max(2e4).optional() }).passthrough().parse(value.taskset.metadata.ordinaryAuthoring ?? {});
-  return authoring.instructions ?? "";
-}
-function validateTasksetPackage(value) {
-  assertBoundedTaskJson2(value, MAX_TASKSET_PACKAGE_BYTES);
-  const result = TasksetPackageSchema.parse(value);
-  const { contentHash: hash, ...content } = result;
-  if (contentHash(content) !== hash) throw new Error("Taskset package content hash differs from its bytes.");
-  const { taskset, environment, verifierSet } = result;
-  assertTasksetRelease2(taskset);
-  const authoring = assertModelTasksetAuthoring(taskset);
-  if (authoring && (result.modelResources || result.learningResources)) throw new Error("Taskset package cannot declare competing authoring graphs.");
-  if (!verifyEnvironmentRelease3(environment) || !verifyVerifierSetRelease3(verifierSet) || !same2(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !same2(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !same2(taskset.environment, environment.contract) || !same2(taskset.graders, verifierSet.graders)) {
-    throw new Error("Taskset package execution releases do not match its Taskset.");
-  }
-  const files = /* @__PURE__ */ new Map();
-  for (const file of result.files) {
-    if (files.has(file.asset.id)) throw new Error(`Duplicate Taskset asset identity: ${file.asset.id}.`);
-    decodeTasksetPackageFile(file);
-    files.set(file.asset.id, file);
-  }
-  function requireAsset(ref) {
-    const file = files.get(ref.id);
-    if (!file || !same2(file.asset, ref)) throw new Error(`Taskset package asset is missing or mismatched: ${ref.id}.`);
-  }
-  for (const task of taskset.tasks) {
-    for (const asset of task.artifactRefs) requireAsset(asset);
-    for (const output of task.requiredOutputs ?? []) if (output.schemaRef) requireAsset(output.schemaRef);
-    if (task.privilegedContextRef && files.get(task.privilegedContextRef)?.asset.visibility !== "host_private") {
-      throw new Error(`Taskset package private context is missing: ${task.id}.`);
-    }
-  }
-  for (const ref of [environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) if (ref) requireAsset(ref);
-  for (const grader of taskset.graders) {
-    const ref = "verifierRef" in grader ? grader.verifierRef : "rubricRef" in grader ? grader.rubricRef : null;
-    if (ref) {
-      requireAsset(ref);
-      if (ref.visibility === "policy") throw new Error(`Taskset grader asset must be private: ${ref.id}.`);
-    }
-  }
-  if (taskset.metrics?.customAggregator) {
-    const aggregator = taskset.metrics.customAggregator;
-    const modules = result.files.filter((file) => file.asset.path === aggregator.module);
-    if (modules.length !== 1 || modules[0].asset.contentHash !== aggregator.contentHash || modules[0].asset.sizeBytes > 524288 || modules[0].asset.visibility === "policy") {
-      throw new Error("Taskset metric module is missing or mismatched, public, or exceeds the source limit.");
-    }
-  }
-  for (const declarations of [taskset.metadata.environmentResources, environment.metadata.resources]) {
-    if (declarations === void 0) continue;
-    for (const resource of z6.array(z6.object({ path: z6.string().min(1) }).passthrough()).parse(declarations)) {
-      if (!result.files.some((file) => file.asset.path === resource.path)) throw new Error(`Taskset environment resource is missing: ${resource.path}.`);
-    }
-  }
-  if (result.learningResources) {
-    if (result.modelResources) throw new Error("Taskset package cannot declare competing authoring graphs.");
-    const learning = validateTasksetLearningResources(taskset, result.learningResources);
-    for (const expected of learningPackageContextFiles(learning)) {
-      if (!same2(files.get(expected.asset.id), expected)) throw new Error("Taskset private context differs from its reviewed evidence.");
-    }
-    for (const asset of learning.assets) requireAsset(asset.asset);
-  } else if (result.modelResources) {
-    const model = validateModelTasksetPackage({ ...result.modelResources, taskset, executionResources: { environment, verifierSet } });
-    for (const asset of model.assets) requireAsset(asset.asset);
-  } else if (["starter", "rewardBinding", "rewardExecution", "modelTasksetDerivation", "learning"].some((key) => taskset.metadata[key] !== void 0)) {
-    throw new Error("Bound Taskset publication requires its complete model resources.");
-  }
-  resolveTasksetPackageExecution(result);
-  resolveTasksetPackageInstructions(result);
-  return result;
-}
-function createTasksetPackage(value) {
-  assertBoundedTaskJson2(value, MAX_TASKSET_PACKAGE_BYTES);
-  const content = TasksetPackageContentSchema.parse(value);
-  return validateTasksetPackage({ ...content, contentHash: contentHash(content) });
-}
-function same2(left, right) {
-  return contentHash({ value: left }) === contentHash({ value: right });
-}
-
-export {
-  modelAuthoredTasksetId,
-  assertModelTasksetAuthoring,
-  ModelStarterEnvironmentAttemptSchema,
-  verifyModelStarterEnvironmentAttempt,
-  ModelStarterExecutionSchema,
-  ModelStarterToolFixtureScriptSchema,
-  modelStarterExecutionAssetId,
-  createModelStarterExecutionAsset,
-  resolveModelStarterExecutionAsset,
-  validateModelStarterExecution,
-  NativeHarnessExperimentAttemptSchema,
-  verifyNativeHarnessExperimentAttempt,
-  ModelTasksetExecutionResourcesSchema,
-  modelTasksetExecutionResourcesAssetId,
-  createModelTasksetExecutionResourcesAsset,
-  resolveModelTasksetExecutionResourcesAsset,
-  ModelTasksetDerivationSchema,
-  ModelTasksetPackageSchema,
-  deriveModelTaskset,
-  compileModelTasksetReward,
-  validateModelTasksetPackage,
-  TasksetPackageLearningResourcesSchema,
-  learningPackageContextFiles,
-  validateTasksetLearningResources,
-  MAX_TASKSET_PACKAGE_BYTES,
-  TasksetPackageFileSchema,
-  decodeTasksetPackageFile,
-  resolveTasksetPackageExecution,
-  createTasksetPackageExecutionFile,
-  TasksetPackageContentSchema,
-  TasksetPackageSchema,
-  tasksetPackageRewardBinding,
-  resolveTasksetPackageInstructions,
-  validateTasksetPackage,
-  createTasksetPackage
-};
-//# sourceMappingURL=chunk-JA3KFK3U.js.map