openpond-sdk 0.2.0 → 0.2.1

package/dist/model-starters.js

@@ -1,9 +1,9 @@
 // src/model-starters.ts
-import { z as z3 } from "zod";
-import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
-import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent2 } from "@openpond/evals/learning";
-import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
-import { assertBoundedTaskJson as assertBoundedTaskJson3, validateTaskValue } from "@openpond/evals/task-schema";
+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";
@@ -357,29 +357,186 @@ function validateModelStarterExecution(execution, taskset, assets) {
   }
 }
 
+// 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 = z3.string().trim().min(1).max(500);
+var IdSchema2 = z5.string().trim().min(1).max(500);
 var RefSchema = ModelProjectVersionedRefSchema;
-var ModelStarterContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.modelStarter.v1"),
+var ModelStarterContentSchema = z5.object({
+  schemaVersion: z5.literal("openpond.modelStarter.v1"),
   id: IdSchema2,
-  revision: z3.number().int().positive(),
-  name: z3.string().trim().min(1).max(200),
-  description: z3.string().trim().min(1).max(2e3),
-  category: z3.enum(["extraction", "support", "operations", "knowledge", "coding", "writing", "classification"]),
+  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: z3.array(RefSchema).min(1).max(100),
-  assets: z3.array(RefSchema).max(1e3),
-  previewTaskIds: z3.array(IdSchema2).min(1).max(8),
+  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: z3.array(ModelProjectTrainingMethodSchema).min(1).max(8),
+  supportedMethods: z5.array(ModelProjectTrainingMethodSchema).min(1).max(8),
   defaultMethod: ModelProjectTrainingMethodSchema,
-  provenance: z3.object({ author: z3.string().min(1).max(200), license: z3.string().min(1).max(200), sourceDescription: z3.string().min(1).max(2e3) }).strict(),
+  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: z3.object({ verifierFixtures: RefSchema.nullable(), baseline: RefSchema.nullable(), training: RefSchema.nullable(), evaluation: RefSchema.nullable() }).strict()
+  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"]) {
@@ -387,23 +544,23 @@ var ModelStarterContentSchema = z3.object({
   }
   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: z3.string().regex(/^[a-f0-9]{64}$/) });
-var ResolvedModelStarterSchema = z3.object({
+var ModelStarterSchema = ModelStarterContentSchema.safeExtend({ contentHash: z5.string().regex(/^[a-f0-9]{64}$/) });
+var ResolvedModelStarterSchema = z5.object({
   starter: ModelStarterSchema,
-  taskset: TasksetReleaseSchema,
-  taskDefinition: TaskDefinitionSchema,
-  rewardBinding: RewardBindingSchema,
-  rewards: z3.array(RewardReleaseSchema).min(1).max(100),
-  assets: z3.array(LearningTextAssetSchema).max(1e3),
+  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 = z3.object({
-  schemaVersion: z3.literal("openpond.modelStarterPrivacyReview.v1"),
-  disposition: z3.literal("synthetic_only"),
-  reviewedBy: z3.string().trim().min(1).max(500),
-  reviewedAt: z3.iso.datetime(),
-  reviewedContentHash: z3.string().regex(/^[a-f0-9]{64}$/),
-  note: z3.string().trim().min(1).max(2e3)
+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;
@@ -415,19 +572,19 @@ function modelStarterPrivacyContentHash(value) {
     const { privacyReview: _review, ...content } = authoring;
     metadata.starterAuthoring = content;
   }
-  return sealLearningContent2({ ...value, starter: { ...starter, taskset: tasksetRef }, taskset: { ...taskset, metadata } }).contentHash;
+  return sealLearningContent4({ ...value, starter: { ...starter, taskset: tasksetRef }, taskset: { ...taskset, metadata } }).contentHash;
 }
-var ModelStarterCreationIntentSchema = z3.object({
+var ModelStarterCreationIntentSchema = z5.object({
   profileId: IdSchema2,
   modelId: IdSchema2,
-  name: z3.string().trim().min(1).max(200),
+  name: z5.string().trim().min(1).max(200),
   starter: RefSchema,
   startingModel: ModelProjectBaseModelSchema,
   method: ModelProjectTrainingMethodSchema,
   rewardBindingRef: RefSchema.nullable().optional()
 }).strict();
 var ModelStarterCreationRequestSchema = ModelStarterCreationIntentSchema.extend({
-  schemaVersion: z3.literal("openpond.modelStarterCreation.v1"),
+  schemaVersion: z5.literal("openpond.modelStarterCreation.v1"),
   operationId: IdSchema2
 }).strict();
 function parseModelStarterCreationRequest(value) {
@@ -446,7 +603,7 @@ async function createModelStarterCreationRequest(value) {
 function validateModelStarterCreation(value, packageValue) {
   const request = parseModelStarterCreationRequest(value);
   const resolved = validateResolvedModelStarter(packageValue);
-  if (!sameLearningRef(request.starter, learningRef2(resolved.starter))) throw new Error("Starter creation references a different package revision.");
+  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 };
 }
@@ -460,7 +617,7 @@ function previewModelStarter(value) {
       name: rewardBinding.name,
       description: rewardBinding.description,
       checks: rewardBinding.sources.map((source) => {
-        const reward = rewards.find((reward2) => sameLearningRef(source.reward, learningRef2(reward2)));
+        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 };
       })
     },
@@ -487,12 +644,12 @@ function validateResolvedModelStarter(value) {
   const resources = [starter, taskset, taskDefinition, rewardBinding, ...rewards, ...assets];
   for (const resource of resources) {
     const { contentHash, ...content } = resource;
-    if (sealLearningContent2(content).contentHash !== contentHash) throw new Error(`Starter resource integrity failed: ${resource.id}.`);
+    if (sealLearningContent4(content).contentHash !== contentHash) throw new Error(`Starter resource integrity failed: ${resource.id}.`);
   }
-  assertTasksetRelease(taskset);
+  assertTasksetRelease2(taskset);
   validateModelStarterExecution(resolved.execution, taskset, assets);
   function exact(expected, resource) {
-    if (!sameLearningRef(expected, learningRef2(resource))) throw new Error(`Starter dependency mismatch: ${expected.id}.`);
+    if (!sameLearningRef2(expected, learningRef3(resource))) throw new Error(`Starter dependency mismatch: ${expected.id}.`);
   }
   exact(starter.taskset, taskset);
   exact(starter.taskDefinition, taskDefinition);
@@ -501,8 +658,8 @@ function validateResolvedModelStarter(value) {
   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 (sealLearningContent2(execution).contentHash !== sealLearningContent2(taskDefinition.execution).contentHash) throw new Error("Starter execution context differs from its task format.");
-  if (sealLearningContent2({ graders: taskset.graders }).contentHash !== sealLearningContent2({ graders: compileBoundGraders(rewardBinding, rewards) }).contentHash) throw new Error("Starter executable graders differ from its Reward binding.");
+  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) {
@@ -526,7 +683,7 @@ function validateResolvedModelStarter(value) {
     ];
     for (const ref of references) {
       const asset = assets.find((asset2) => asset2.id === ref.id);
-      if (!asset || sealLearningContent2(asset.asset).contentHash !== sealLearningContent2(ref).contentHash) throw new Error(`Starter Reward source is missing or changed: ${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}.`);
     }
   }
@@ -534,12 +691,12 @@ function validateResolvedModelStarter(value) {
   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 = sealLearningContent2({ input: task.input, context: task.policyVisibleContext }).contentHash;
+    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 (!validateTaskValue(taskDefinition.inputSchema, task.input).valid) throw new Error(`Starter task input does not match its format: ${task.id}.`);
-    if (task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Starter expected output does not match its format: ${task.id}.`);
+    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);
@@ -556,15 +713,23 @@ export {
   ModelStarterPrivacyReviewSchema,
   ModelStarterSchema,
   ModelStarterToolFixtureScriptSchema,
+  ModelTasksetDerivationSchema,
+  ModelTasksetExecutionResourcesSchema,
+  ModelTasksetPackageSchema,
   ResolvedModelStarterSchema,
   createModelStarterCreationRequest,
   createModelStarterExecutionAsset,
+  createModelTasksetExecutionResourcesAsset,
+  deriveModelTaskset,
   modelStarterExecutionAssetId,
   modelStarterPrivacyContentHash,
+  modelTasksetExecutionResourcesAssetId,
   parseModelStarterCreationRequest,
   previewModelStarter,
   resolveModelStarterExecutionAsset,
+  resolveModelTasksetExecutionResourcesAsset,
   validateModelStarterCreation,
+  validateModelTasksetPackage,
   validateResolvedModelStarter,
   verifyModelStarterEnvironmentAttempt
 };