openpond-sdk 0.6.7 → 0.7.0

package/dist/taskset-packages.js

@@ -1,3 +1,11 @@
+import {
+  OpenPondTasksetPackageClient,
+  OpenPondTasksetPackageError,
+  TasksetPackageModelConfigurationSchema,
+  TasksetPackagePublicationSchema,
+  TasksetPackageReadbackSchema,
+  TasksetPackageReceiptSchema
+} from "./chunk-QABCKPW6.js";
 import {
   ModelBatchReviewInspectionSchema,
   ModelBatchReviewReceiptSchema,
@@ -6,61 +14,56 @@ import {
 import {
   importedPackageGraders,
   learningVerifierModule,
-  materializePortableTasksetRelease,
-  portableTasksetEnvironment,
-  portableTasksetTools,
-  projectLearningBatchGraders,
-  projectPortableTaskRecord,
-  projectPreferenceComparisonRelease,
-  resolvePortableTasksetRewardExecution
-} from "./chunk-YGCHXNPI.js";
+  projectLearningBatchGraders
+} from "./chunk-3HV3G6DG.js";
+import {
+  AuthoredTasksetFileInventorySchema,
+  compileModelTasksetDraftWorkspace,
+  isGeneratedTasksetPublicationFilePath,
+  prepareAuthoredTasksetSource,
+  prepareModelTasksetDraft,
+  publishModelTasksetDraftPackage
+} from "./chunk-DNBAJUVR.js";
 import {
-  OpenPondTasksetPackageClient,
-  OpenPondTasksetPackageError,
   TasksetDraftSchema,
-  TasksetPackageModelConfigurationSchema,
-  TasksetPackagePublicationSchema,
-  TasksetPackageReadbackSchema,
-  TasksetPackageReceiptSchema,
   configuredTasksetDraftFiles,
   createTasksetDraft,
   createTasksetDraftWorkspace,
   decodeTasksetDraftWorkspaceFile,
-  isManagedTasksetDraftFilePath,
-  publishTasksetDraft,
-  renderTasksetDraftManifests,
-  validateTasksetDraftWorkspace
-} from "./chunk-EJYSXE4V.js";
+  isManagedTasksetDraftFilePath
+} from "./chunk-32H2EJRA.js";
+import {
+  materializePortableTasksetRelease,
+  portableTasksetEnvironment,
+  portableTasksetTools,
+  projectPortableTaskRecord,
+  projectPreferenceComparisonRelease,
+  resolvePortableTasksetRewardExecution
+} from "./chunk-DT7FRNIZ.js";
 import {
   GraderFixtureSchema,
   TasksetEnvironmentResourceSchema,
   TasksetSchema,
   TasksetSourceRefSchema,
   computeTasksetHash
-} from "./chunk-TXQHWOFM.js";
+} from "./chunk-LGEF4S5I.js";
 import {
   MAX_TASKSET_PACKAGE_BYTES,
-  ModelStarterExecutionSchema,
-  ModelTasksetDerivationSchema,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
   TasksetPackageLearningResourcesSchema,
   TasksetPackageSchema,
-  assertModelTasksetAuthoring,
   compileModelTasksetReward,
   createTasksetPackage,
   createTasksetPackageExecutionFile,
   decodeTasksetPackageFile,
-  deriveModelTaskset,
   learningPackageContextFiles,
-  modelAuthoredTasksetId,
-  modelStarterExecutionAssetId,
   resolveTasksetPackageExecution,
   resolveTasksetPackageInstructions,
   tasksetPackageRewardBinding,
   validateTasksetLearningResources,
   validateTasksetPackage
-} from "./chunk-42YOB36J.js";
+} from "./chunk-WOPM32SE.js";
 import {
   ModelTasksetAuthoringOwnerSchema,
   ModelTasksetAuthoringSchema,
@@ -72,16 +75,15 @@ import {
   TasksetDraftFilePathSchema,
   TasksetDraftFileSchema
 } from "./chunk-2U54EOXJ.js";
-import "./chunk-FPOW5PU7.js";
+import "./chunk-CGIMLZE5.js";
+import "./chunk-TCHAWJMB.js";
+import "./chunk-3KXDH6OB.js";
 import "./chunk-A4ZDOZKP.js";
-import "./chunk-EAEYAU4R.js";
+import "./chunk-Y4NGWGTA.js";
 import {
-  ImmutableAssetRefSchema,
   contentHash,
   sha256
 } from "./chunk-QUOW6URQ.js";
-import "./chunk-TCHAWJMB.js";
-import "./chunk-3KXDH6OB.js";
 
 // src/model-ordinary-taskset-reward.ts
 import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sealLearningContent } from "@openpond/evals/learning";
@@ -385,161 +387,8 @@ async function readReceipt(transaction, request, pointers) {
   });
 }
 
-// src/model-taskset-authoring.ts
-import { createVerifierSetRelease } from "@openpond/evals";
-import { learningRef as learningRef5, sameLearningRef as sameLearningRef4, sealLearningContent as sealLearningContent4 } from "@openpond/evals/learning";
-import { TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
-
-// src/model-bound-taskset-authoring.ts
-import { LearningTextAssetSchema as LearningTextAssetSchema2, TaskDefinitionSchema as TaskDefinitionSchema3, learningRef as learningRef4, sameLearningRef as sameLearningRef3, sealLearningContent as sealLearningContent3 } from "@openpond/evals/learning";
-import { TasksetReleaseSchema } from "@openpond/evals/tasksets";
-function publishBoundModelTasksetDraftPackage(input) {
-  const source = validateTasksetPackage(input.source);
-  const edited = validateTasksetPackage(input.edited);
-  const prepared = input.preparation;
-  if (prepared.authoringGraph !== "bound" || !source.modelResources || source.learningResources || edited.modelResources || edited.learningResources) throw new Error("Bound task editing requires its source Reward and an ordinary edited workspace.");
-  if (source.contentHash !== prepared.sourcePackageHash || !sameLearningRef3(learningRef4(source.taskset), prepared.sourceTasksetRef)) throw new Error("Bound draft differs from its retained source package.");
-  const normalizedGraders = (value) => value.taskset.graders.map((grader) => grader.kind === "custom_verifier" ? { ...grader, exportName: grader.exportName ?? "verify" } : grader);
-  if (contentHash(normalizedGraders(source)) !== contentHash(normalizedGraders(edited))) throw new Error("Edit the saved Reward in Rewards before changing this Taskset's graders.");
-  const resources = source.modelResources;
-  const assets = new Map(resources.assets.map((asset) => [asset.id, asset]));
-  const execution = resolveTasksetPackageExecution(edited);
-  const sourceExecution = resolveTasksetPackageExecution(source);
-  const environmentContent = (value) => {
-    const { id: _id, revision: _revision, contentHash: _hash, metadata, ...contract } = value;
-    const { javascriptEnvironment: _javascript, ...retained } = metadata;
-    return { ...contract, metadata: { ...retained, resources: retained.resources ?? [] } };
-  };
-  const javascriptContent = (value) => {
-    if (!value) return null;
-    const { id: _id, revision: _revision, contentHash: _hash, ...contract } = value.execution.javascript;
-    return contract;
-  };
-  const unchangedEnvironment = contentHash(environmentContent(source.environment)) === contentHash(environmentContent(edited.environment)) && contentHash(javascriptContent(sourceExecution)) === contentHash(javascriptContent(execution));
-  const selectedEnvironment = unchangedEnvironment ? source.environment : edited.environment;
-  const selectedExecution = unchangedEnvironment ? sourceExecution : execution;
-  const requiredIds = /* @__PURE__ */ new Set([
-    ...resources.assets.map((asset) => asset.id),
-    ...edited.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : []),
-    ...[edited.environment.actionSchemaRef, edited.environment.observationSchemaRef, edited.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : []),
-    ...execution?.assets.map((asset) => asset.id) ?? []
-  ]);
-  for (const id of requiredIds) {
-    const file = edited.files.find((file2) => file2.asset.id === id);
-    if (!file) throw new Error(`Bound Taskset asset is missing: ${id}.`);
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-    assets.set(id, LearningTextAssetSchema2.parse(sealLearningContent3({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text })));
-  }
-  const instructions = resolveTasksetPackageInstructions(edited);
-  const { contentHash: _definitionHash, ...definitionContent } = resources.taskDefinition;
-  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = edited.taskset;
-  const taskDefinition = TaskDefinitionSchema3.parse(sealLearningContent3({
-    ...definitionContent,
-    instructions,
-    execution: { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease }
-  }));
-  const { contentHash: _taskHash, ...taskContent } = edited.taskset;
-  const taskset = TasksetReleaseSchema.parse(sealLearningContent3({ ...taskContent, tasks: edited.taskset.tasks.map((task) => resources.instructionMode === "per_task" ? task : { ...task, policyVisibleContext: { ...task.policyVisibleContext, instructions } }) }));
-  const derived = compileModelTasksetReward({
-    owner: prepared.lineage.owner,
-    source: { ...resources, taskset: source.taskset, executionResources: { environment: source.environment, verifierSet: source.verifierSet } },
-    rewardBinding: resources.rewardBinding,
-    rewards: resources.rewards,
-    assets: [...assets.values()],
-    edits: { taskset, taskDefinition, executionResources: { environment: selectedEnvironment, verifierSet: edited.verifierSet }, ...selectedExecution ? { execution: selectedExecution.execution } : {} }
-  });
-  const lineage = ModelTasksetDerivationSchema.parse(derived.taskset.metadata.modelTasksetDerivation);
-  if (derived.taskset.id !== prepared.tasksetId || derived.taskset.revision !== prepared.tasksetRevision || contentHash({ ...lineage, schemaVersion: prepared.lineage.schemaVersion }) !== contentHash(prepared.lineage)) throw new Error("Bound draft differs from its retained ownership lineage.");
-  const { taskset: published, executionResources, ...modelResources } = derived;
-  return createTasksetPackage({ schemaVersion: "openpond.tasksetPackage.v1", taskset: published, ...executionResources, modelResources, files: edited.files });
-}
-
-// src/model-taskset-authoring.ts
-function prepareModelTasksetDraft(input) {
-  const request = ModelTasksetDraftRequestSchema.parse(input.request);
-  const owner = ModelTasksetAuthoringOwnerSchema.parse(input.owner);
-  const source = validateTasksetPackage(input.source);
-  if (source.learningResources) throw new Error("Reviewed Tasksets require their reviewed authoring workflow.");
-  if (source.contentHash !== request.sourcePackageHash) throw new Error("Taskset draft source package changed.");
-  if (source.modelResources) {
-    const derived = deriveModelTaskset({
-      owner,
-      source: { ...source.modelResources, taskset: source.taskset, executionResources: { environment: source.environment, verifierSet: source.verifierSet } },
-      rewardBinding: source.modelResources.rewardBinding,
-      rewards: source.modelResources.rewards,
-      assets: source.modelResources.assets
-    });
-    const lineage2 = derived.taskset.metadata.modelTasksetDerivation;
-    return ModelTasksetDraftPreparationSchema.parse({
-      schemaVersion: "openpond.modelTasksetDraftPreparation.v1",
-      draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`,
-      requestHash: contentHash(request),
-      sourcePackageHash: source.contentHash,
-      sourceTasksetRef: learningRef5(source.taskset),
-      tasksetId: derived.taskset.id,
-      tasksetRevision: derived.taskset.revision,
-      lineage: { ...lineage2, schemaVersion: "openpond.modelTasksetAuthoring.v1" },
-      authoringGraph: "bound"
-    });
-  }
-  const previous = assertModelTasksetAuthoring(source.taskset);
-  const owned = previous && contentHash(previous.owner) === contentHash(owner);
-  const root = owned ? previous.root : learningRef5(source.taskset);
-  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef5(source.taskset) };
-  return ModelTasksetDraftPreparationSchema.parse({
-    schemaVersion: "openpond.modelTasksetDraftPreparation.v1",
-    draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`,
-    requestHash: contentHash(request),
-    sourcePackageHash: source.contentHash,
-    sourceTasksetRef: learningRef5(source.taskset),
-    tasksetId: modelAuthoredTasksetId(lineage),
-    tasksetRevision: owned ? source.taskset.revision + 1 : 1,
-    lineage
-  });
-}
-function publishModelTasksetDraftPackage(input) {
-  const prepared = ModelTasksetDraftPreparationSchema.parse(input.preparation);
-  if (!sameLearningRef4(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error("Taskset draft preparation differs from its source lineage.");
-  if (prepared.authoringGraph === "bound") {
-    if (!input.source) throw new Error("Bound Taskset authoring requires its retained source package.");
-    return publishBoundModelTasksetDraftPackage({ preparation: prepared, source: input.source, edited: input.edited });
-  }
-  const edited = requireOrdinaryPackage(input.edited);
-  const { contentHash: _verifierHash, ...verifierContent } = edited.verifierSet;
-  const verifierSet = createVerifierSetRelease({
-    ...verifierContent,
-    id: `${prepared.tasksetId}-verifiers`,
-    revision: prepared.tasksetRevision,
-    calibrationReceiptRefs: [],
-    metadata: { sourceVerifierSet: learningRef5(edited.verifierSet) }
-  });
-  const { contentHash: _hash, ...content } = edited.taskset;
-  const taskset = TasksetReleaseSchema2.parse(sealLearningContent4({
-    ...content,
-    id: prepared.tasksetId,
-    revision: prepared.tasksetRevision,
-    verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash },
-    metadata: {
-      modelTasksetAuthoring: prepared.lineage,
-      ...edited.taskset.metadata.environmentResources === void 0 ? {} : { environmentResources: edited.taskset.metadata.environmentResources },
-      ...edited.taskset.metadata.ordinaryAuthoring === void 0 ? {} : { ordinaryAuthoring: edited.taskset.metadata.ordinaryAuthoring }
-    }
-  }));
-  const resolved = resolveTasksetPackageExecution(edited);
-  const files = resolved ? [
-    ...edited.files.filter((file) => file.asset.id !== modelStarterExecutionAssetId(edited.taskset)),
-    createTasksetPackageExecutionFile({ ...resolved.execution, verifierSet })
-  ] : edited.files;
-  return createTasksetPackage({ schemaVersion: "openpond.tasksetPackage.v1", taskset, environment: edited.environment, verifierSet, files });
-}
-function requireOrdinaryPackage(value) {
-  const result = validateTasksetPackage(value);
-  if (result.modelResources || result.learningResources) throw new Error("This Taskset requires its bound or reviewed authoring workflow.");
-  return result;
-}
-
 // src/taskset-package-projection.ts
-import { learningRef as learningRef6, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+import { learningRef as learningRef4, taskBatchPackageMetadata as taskBatchPackageMetadata3, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
 function prepareImportedTasksetPackage(input) {
   const value = validateTasksetPackage(input.package);
   const release = value.taskset;
@@ -662,8 +511,8 @@ function prepareImportedTasksetPackage(input) {
       ...learning ? { learning } : {},
       portableFileInventory: value.files.map((file) => ({ asset: file.asset, sourcePath: file.asset.path })),
       ...resources ? {
-        taskDefinition: learningRef6(resources.taskDefinition),
-        rewardBinding: learningRef6(resources.rewardBinding),
+        taskDefinition: learningRef4(resources.taskDefinition),
+        rewardBinding: learningRef4(resources.rewardBinding),
         rewardExecution: { binding: resources.rewardBinding, rewards: resources.rewards }
       } : {},
       portableCapabilities: release.capabilities,
@@ -677,189 +526,18 @@ function tasksetPackageSourceId(profileId, packageHash) {
   return `package-${contentHash({ profileId, packageHash })}`;
 }
 
-// src/taskset-authored-files.ts
-import { z } from "zod";
-
-// src/taskset-authored-tool-environment.ts
-import { createEnvironmentRelease } from "@openpond/evals";
-import { JavaScriptEnvironmentDefinitionSchema } from "@openpond/evals/javascript-environment";
-import { learningRef as learningRef7, sealLearningContent as sealLearningContent5 } from "@openpond/evals/learning";
-function prepareAuthoredToolEnvironment(taskset, bytes, inventory, adapterId) {
-  if (taskset.environment.entrypoint !== "openpond.javascript-environment.v1") return { taskset, inventory, generatedFiles: [] };
-  const declarationPath = "environment/execution.json";
-  const declaration = bytes.get(declarationPath);
-  if (!declaration || declaration.length > 524288) throw new Error("Authored tool environment requires its bounded private execution declaration.");
-  const previous = ModelStarterExecutionSchema.parse(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(declaration)));
-  const repin = (ref) => {
-    if (!ref) return null;
-    const file2 = inventory.find((file3) => file3.asset.id === ref.id && file3.asset.path === ref.path);
-    if (!file2) throw new Error(`Authored environment dependency is missing: ${ref.id}.`);
-    return file2.asset;
-  };
-  const { contentHash: _javascriptHash, ...javascriptContent } = previous.javascript;
-  const javascript = JavaScriptEnvironmentDefinitionSchema.parse(sealLearningContent5({
-    ...javascriptContent,
-    id: `javascript-${taskset.id}`,
-    revision: taskset.revision,
-    module: repin(previous.javascript.module)
-  }));
-  if (contentHash(javascript.tools) !== contentHash(taskset.environment.metadata.portableTools) || contentHash(javascript.tools.map((tool) => tool.name)) !== contentHash(taskset.environment.toolNames)) throw new Error("Authored environment tools differ from the Taskset's declared tools.");
-  const environment = createEnvironmentRelease({
-    schemaVersion: "openpond.environmentRelease.v1",
-    id: `environment-${taskset.id}`,
-    revision: taskset.revision,
-    contract: portableTasksetEnvironment(taskset),
-    actionSchemaRef: repin(previous.environment.actionSchemaRef),
-    observationSchemaRef: repin(previous.environment.observationSchemaRef),
-    stateSchemaRef: repin(previous.environment.stateSchemaRef),
-    artifactCollection: previous.environment.artifactCollection,
-    adapterConformanceHashes: {},
-    metadata: { javascriptEnvironment: learningRef7(javascript), resources: taskset.environment.resources ?? [] }
-  });
-  const prepared = TasksetSchema.parse({ ...taskset, environment: {
-    ...taskset.environment,
-    metadata: { ...taskset.environment.metadata, portableExecutionResources: { environment } }
-  } });
-  const releases = materializePortableTasksetRelease({ taskset: prepared, adapterId });
-  const file = createTasksetPackageExecutionFile({ javascript, environment, verifierSet: releases.verifierSetRelease });
-  const nextInventory = [...inventory.filter((entry) => entry.sourcePath !== declarationPath), { asset: file.asset, sourcePath: declarationPath }];
-  const finalized = TasksetSchema.parse({ ...prepared, metadata: { ...prepared.metadata, portableFileInventory: nextInventory } });
-  return {
-    taskset: TasksetSchema.parse({ ...finalized, contentHash: computeTasksetHash(finalized) }),
-    inventory: nextInventory,
-    generatedFiles: [{ path: declarationPath, role: "environment", content: new TextDecoder().decode(decodeTasksetPackageFile(file)) }]
-  };
-}
-
-// src/taskset-authored-files.ts
-var AuthoredTasksetFileInventorySchema = z.array(z.object({
-  asset: ImmutableAssetRefSchema,
-  sourcePath: z.string().min(1)
-}).strict()).max(1e4);
-var GENERATED_MANIFESTS = /* @__PURE__ */ new Set(["taskset.json", "capabilities.json", "data/tasks.jsonl", "graders/graders.json", "fixtures/grader-fixtures.json", "environment/taskset.ts"]);
-function isGeneratedTasksetPublicationFilePath(path) {
-  return GENERATED_MANIFESTS.has(path);
-}
-function prepareAuthoredTasksetSource(tasksetInput, sourceFiles, adapterId) {
-  const taskset = TasksetSchema.parse(tasksetInput);
-  if (taskset.metadata.taskDefinition !== void 0 || taskset.metadata.rewardBinding !== void 0) return { taskset, generatedFiles: [] };
-  const bytes = /* @__PURE__ */ new Map();
-  let total = 0;
-  for (const [name, data] of sourceFiles) {
-    TasksetDraftFilePathSchema.parse(name);
-    total += data.byteLength;
-    if (bytes.size >= 1e4 || total > MAX_TASKSET_PACKAGE_BYTES * 3 / 4) throw new Error("Taskset source exceeds the package byte limit.");
-    bytes.set(name, data.slice());
-  }
-  const aggregator = taskset.metrics?.customAggregator;
-  const aggregatorBytes = aggregator ? bytes.get(aggregator.module) : void 0;
-  if (aggregator && !aggregatorBytes) throw new Error("Declared Taskset metric module is missing.");
-  const metrics = aggregator && aggregatorBytes ? { ...taskset.metrics, customAggregator: { ...aggregator, contentHash: sha256(aggregatorBytes) } } : taskset.metrics;
-  const inventory = /* @__PURE__ */ new Map();
-  const declaredPaths = /* @__PURE__ */ new Set();
-  const generatedFiles = [];
-  const ref = (id, sourcePath, mediaType, visibility) => {
-    const source = bytes.get(sourcePath);
-    if (!source) throw new Error(`Declared Taskset file is missing: ${sourcePath}.`);
-    return { id, path: sourcePath, contentHash: sha256(source), sizeBytes: source.byteLength, mediaType, visibility };
-  };
-  const add = (asset, sourcePath = asset.path) => {
-    const previous = inventory.get(asset.id);
-    if (previous && contentHash(previous) !== contentHash({ asset, sourcePath })) throw new Error(`Conflicting Taskset file identity: ${asset.id}.`);
-    const source = bytes.get(sourcePath);
-    if (!source || source.length !== asset.sizeBytes || sha256(source) !== asset.contentHash) throw new Error(`Taskset file differs from its declared bytes: ${asset.id}.`);
-    inventory.set(asset.id, { asset, sourcePath });
-    declaredPaths.add(sourcePath);
-  };
-  for (const task of taskset.tasks) {
-    const portable = projectPortableTaskRecord(task);
-    for (const asset of portable.artifactRefs) add(asset, task.assets?.find((candidate) => candidate.id === asset.id)?.artifactRef ?? asset.path);
-    for (const output of portable.requiredOutputs ?? []) if (output.schemaRef) add(output.schemaRef);
-  }
-  for (const resource of taskset.environment.resources ?? []) add(ref(resource.id, resource.path, resource.mediaType ?? "application/octet-stream", resource.visibility === "policy_visible" ? "policy" : "host_private"));
-  const graders = taskset.graders.map((grader) => {
-    if (grader.kind === "custom_verifier") {
-      let asset = ref(`verifier-${grader.id}`, grader.module, "application/javascript", "host_private");
-      const previous = ImmutableAssetRefSchema.safeParse(grader.metadata.portableVerifierRef);
-      if (previous.success && previous.data.contentHash === asset.contentHash && previous.data.sizeBytes === asset.sizeBytes) asset = previous.data;
-      add(asset, grader.module);
-      return { ...grader, metadata: { ...grader.metadata, portableVerifierRef: asset } };
-    }
-    if (grader.kind === "human" || grader.kind === "model_judge") {
-      const content = new TextEncoder().encode(grader.rubric);
-      const sourcePath = `graders/rubric-${sha256(content)}.md`;
-      bytes.set(sourcePath, content);
-      const asset = ref(`rubric-${grader.id}`, sourcePath, "text/markdown", "verifier");
-      add(asset);
-      generatedFiles.push({ path: sourcePath, role: "verifier", content: grader.rubric });
-      return { ...grader, metadata: { ...grader.metadata, portableRubricRef: asset } };
-    }
-    return grader;
-  });
-  if (aggregator && ![...inventory.values()].some((file) => file.asset.path === aggregator.module && file.sourcePath === aggregator.module && file.asset.visibility !== "policy")) {
-    add(ref(`metric-${contentHash(aggregator.module)}`, aggregator.module, "application/javascript", "host_private"));
-  }
-  const previousInventory = AuthoredTasksetFileInventorySchema.parse(taskset.metadata.portableFileInventory ?? []);
-  for (const name of [...bytes.keys()].sort()) if (!declaredPaths.has(name)) {
-    const previous = previousInventory.find((file) => file.sourcePath === name && !inventory.has(file.asset.id));
-    add(previous ? { ...ref(previous.asset.id, name, previous.asset.mediaType, previous.asset.visibility), path: previous.asset.path } : ref(`taskset-file-${contentHash(name)}`, name, "application/octet-stream", "host_private"), name);
-  }
-  const { importedPackageHash, derivedPortableMetadata: _derived, ...metadata } = taskset.metadata;
-  const environmentMetadata = { ...taskset.environment.metadata };
-  if (environmentMetadata.portableExecutionResources !== void 0) {
-    const resources = z.object({ environment: z.unknown(), verifierSet: z.unknown().optional() }).parse(environmentMetadata.portableExecutionResources);
-    environmentMetadata.portableExecutionResources = { environment: resources.environment };
-  }
-  const prepared = TasksetSchema.parse({
-    ...taskset,
-    graders,
-    metrics,
-    environment: { ...taskset.environment, metadata: environmentMetadata },
-    metadata: { ...metadata, ...importedPackageHash === void 0 ? {} : { sourceImportedPackageHash: importedPackageHash }, portableFileInventory: AuthoredTasksetFileInventorySchema.parse([...inventory.values()].sort((left, right) => left.asset.id.localeCompare(right.asset.id))) }
-  });
-  const executable = prepareAuthoredToolEnvironment(prepared, bytes, [...inventory.values()], adapterId);
-  return { taskset: TasksetSchema.parse({ ...executable.taskset, contentHash: computeTasksetHash(executable.taskset) }), generatedFiles: [...generatedFiles, ...executable.generatedFiles] };
-}
-
-// src/taskset-draft-package-compiler.ts
-function compileModelTasksetDraftWorkspace(input) {
-  const workspace = validateTasksetDraftWorkspace(input.workspace);
-  const preparation = input.preparation === null ? null : ModelTasksetDraftPreparationSchema.parse(input.preparation);
-  if (!workspace.draft.modelScope) throw new Error("Taskset draft requires a Model owner.");
-  if (preparation ? workspace.draft.id !== preparation.draftId || workspace.draft.modelScope.modelId !== preparation.lineage.owner.modelId || workspace.draft.profileId !== preparation.lineage.owner.scopeId || contentHash(workspace.draft.modelScope.source ?? null) !== contentHash(preparation) : workspace.draft.modelScope.source !== void 0) throw new Error("Taskset draft differs from its retained source preparation.");
-  const taskset = publishTasksetDraft({ draft: workspace.draft, now: workspace.draft.updatedAt, sourcePackageHash: workspace.contentHash });
-  const files = new Map(workspace.files.map((file) => [file.path, decodeTasksetDraftWorkspaceFile(file)]));
-  for (const [path, source] of renderTasksetDraftManifests(workspace.draft)) if (!isGeneratedTasksetPublicationFilePath(path)) files.set(path, new TextEncoder().encode(source));
-  const authored = prepareAuthoredTasksetSource(taskset, files, input.adapterId);
-  for (const file of authored.generatedFiles) files.set(file.path, new TextEncoder().encode(file.content));
-  const releases = materializePortableTasksetRelease({ taskset: authored.taskset, adapterId: input.adapterId });
-  const inventory = AuthoredTasksetFileInventorySchema.parse(authored.taskset.metadata.portableFileInventory);
-  const edited = createTasksetPackage({
-    schemaVersion: "openpond.tasksetPackage.v1",
-    taskset: releases.tasksetRelease,
-    environment: releases.environmentRelease,
-    verifierSet: releases.verifierSetRelease,
-    files: inventory.map((entry) => {
-      const bytes = files.get(entry.sourcePath);
-      if (!bytes) throw new Error(`Captured Taskset file is missing: ${entry.sourcePath}.`);
-      return { asset: entry.asset, base64: Buffer.from(bytes).toString("base64") };
-    })
-  });
-  return preparation ? publishModelTasksetDraftPackage({ preparation, edited, source: input.source }) : edited;
-}
-
 // src/taskset-draft-source.ts
-import { z as z2 } from "zod";
-import { learningRef as learningRef8, sameLearningRef as sameLearningRef5 } from "@openpond/evals/learning";
-var TasksetDraftSourceInitializationSchema = z2.object({
+import { z } from "zod";
+import { learningRef as learningRef5, sameLearningRef as sameLearningRef3 } from "@openpond/evals/learning";
+var TasksetDraftSourceInitializationSchema = z.object({
   draft: TasksetDraftSchema,
-  filePaths: z2.array(z2.object({ assetId: z2.string().min(1), paths: z2.array(TasksetDraftFilePathSchema).min(1).max(1e4) }).strict()).max(1e4)
+  filePaths: z.array(z.object({ assetId: z.string().min(1), paths: z.array(TasksetDraftFilePathSchema).min(1).max(1e4) }).strict()).max(1e4)
 }).strict();
 function prepareTasksetDraftSource(input) {
   const source = validateTasksetPackage(input.source);
   const original = TasksetDraftSchema.parse(input.sourceDraft);
   const preparation = ModelTasksetDraftPreparationSchema.parse(input.preparation);
-  if (source.contentHash !== preparation.sourcePackageHash || !sameLearningRef5(learningRef8(source.taskset), preparation.sourceTasksetRef)) throw new Error("Taskset draft preparation differs from its source package.");
+  if (source.contentHash !== preparation.sourcePackageHash || !sameLearningRef3(learningRef5(source.taskset), preparation.sourceTasksetRef)) throw new Error("Taskset draft preparation differs from its source package.");
   if (source.learningResources) throw new Error("Reviewed Tasksets require their reviewed authoring workflow.");
   if (Boolean(source.modelResources) !== (preparation.authoringGraph === "bound")) throw new Error("Taskset draft authoring graph differs from its source.");
   const inventory = AuthoredTasksetFileInventorySchema.parse(original.metadata.portableFileInventory ?? []);