openpond-sdk 0.9.9 → 0.11.0

package/dist/taskset-packages.js

@@ -1,21 +1,33 @@
+import {
+  LearningDomainError,
+  TasksetDraftSourceInitializationSchema,
+  beginModelBatchReview,
+  bindOrdinaryModelTasksetReward,
+  findModelBatchReview,
+  inspectModelBatchPackage,
+  materializeTasksetDraftWorkspace,
+  prepareImportedTasksetPackage,
+  prepareTasksetDraftSource,
+  tasksetPackageSourceId
+} from "./chunk-HOAYWW33.js";
 import {
   OpenPondTasksetPackageClient,
   OpenPondTasksetPackageError,
   TasksetPackageModelConfigurationSchema,
   TasksetPackagePublicationSchema,
   TasksetPackageReadbackSchema,
-  TasksetPackageReceiptSchema
-} from "./chunk-XMKEFQ62.js";
+  TasksetPackageReceiptSchema,
+  TasksetReleasePackageReadbackSchema
+} from "./chunk-PJ2VLNJF.js";
 import {
   ModelBatchReviewInspectionSchema,
   ModelBatchReviewReceiptSchema,
   ModelBatchReviewRequestSchema
 } from "./chunk-YVUIHH6Z.js";
 import {
-  importedPackageGraders,
   learningVerifierModule,
   projectLearningBatchGraders
-} from "./chunk-3HV3G6DG.js";
+} from "./chunk-NHCGOFQW.js";
 import {
   AuthoredTasksetFileInventorySchema,
   compileModelTasksetDraftWorkspace,
@@ -23,15 +35,8 @@ import {
   prepareAuthoredTasksetSource,
   prepareModelTasksetDraft,
   publishModelTasksetDraftPackage
-} from "./chunk-6D4JIOOC.js";
-import {
-  TasksetDraftSchema,
-  configuredTasksetDraftFiles,
-  createTasksetDraft,
-  createTasksetDraftWorkspace,
-  decodeTasksetDraftWorkspaceFile,
-  isManagedTasksetDraftFilePath
-} from "./chunk-32H2EJRA.js";
+} from "./chunk-IXBSFJCX.js";
+import "./chunk-R3M6BIOK.js";
 import "./chunk-K3JCP4FO.js";
 import {
   materializePortableTasksetRelease,
@@ -40,21 +45,14 @@ import {
   projectPortableTaskRecord,
   projectPreferenceComparisonRelease,
   resolvePortableTasksetRewardExecution
-} from "./chunk-DT7FRNIZ.js";
-import {
-  GraderFixtureSchema,
-  TasksetEnvironmentResourceSchema,
-  TasksetSchema,
-  TasksetSourceRefSchema,
-  computeTasksetHash
-} from "./chunk-LGEF4S5I.js";
+} from "./chunk-CSWVE3E6.js";
+import "./chunk-XJDWHTH5.js";
 import {
   MAX_TASKSET_PACKAGE_BYTES,
   TasksetPackageContentSchema,
   TasksetPackageFileSchema,
   TasksetPackageLearningResourcesSchema,
   TasksetPackageSchema,
-  compileModelTasksetReward,
   createTasksetPackage,
   createTasksetPackageExecutionFile,
   decodeTasksetPackageFile,
@@ -64,7 +62,7 @@ import {
   tasksetPackageRewardBinding,
   validateTasksetLearningResources,
   validateTasksetPackage
-} from "./chunk-WOPM32SE.js";
+} from "./chunk-JA3KFK3U.js";
 import {
   ModelTasksetAuthoringOwnerSchema,
   ModelTasksetAuthoringSchema,
@@ -76,547 +74,20 @@ import {
   TasksetDraftFilePathSchema,
   TasksetDraftFileSchema
 } from "./chunk-2U54EOXJ.js";
-import "./chunk-JCPLAIZL.js";
+import "./chunk-5U25KAJM.js";
+import "./chunk-KQWCXW3A.js";
+import "./chunk-XEUOJ5WF.js";
+import "./chunk-2NSNBED7.js";
+import "./chunk-WX22WN33.js";
+import "./chunk-2JKV5OJO.js";
 import "./chunk-TCHAWJMB.js";
 import "./chunk-3KXDH6OB.js";
-import "./chunk-Y4NGWGTA.js";
-import {
-  contentHash,
-  sha256
-} from "./chunk-QUOW6URQ.js";
-
-// src/model-ordinary-taskset-reward.ts
-import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sealLearningContent } from "@openpond/evals/learning";
-function bindOrdinaryModelTasksetReward(input) {
-  const source = validateTasksetPackage(input.source);
-  if (source.modelResources || source.learningResources) throw new Error("Binding an ordinary Reward requires an ordinary source package.");
-  const instructions = resolveTasksetPackageInstructions(source);
-  if (!instructions.trim()) throw new Error("Add collection instructions before selecting a saved Reward.");
-  const assets = /* @__PURE__ */ new Map();
-  const execution = resolveTasksetPackageExecution(source);
-  for (const asset of execution?.assets ?? []) assets.set(asset.id, asset);
-  const contextIds = /* @__PURE__ */ new Set([
-    ...source.taskset.tasks.flatMap((task) => task.privilegedContextRef ? [task.privilegedContextRef] : []),
-    ...[source.environment.actionSchemaRef, source.environment.observationSchemaRef, source.environment.stateSchemaRef].flatMap((ref) => ref ? [ref.id] : [])
-  ]);
-  for (const id of contextIds) {
-    if (assets.has(id)) continue;
-    const file = source.files.find((file2) => file2.asset.id === id);
-    if (!file) throw new Error(`Source Taskset context is missing: ${id}.`);
-    const text = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-    assets.set(id, LearningTextAssetSchema.parse(sealLearningContent({ schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1, asset: file.asset, text })));
-  }
-  for (const asset of input.assets) {
-    const original = source.files.find((file) => file.asset.id === asset.id);
-    if (original && sealLearningContent({ asset: original.asset }).contentHash !== sealLearningContent({ asset: asset.asset }).contentHash) throw new Error(`Selected Reward conflicts with a source asset: ${asset.id}.`);
-    assets.set(asset.id, asset);
-  }
-  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = source.taskset;
-  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent({
-    schemaVersion: "openpond.taskDefinition.v1",
-    id: `${source.taskset.id}-definition`,
-    revision: 1,
-    name: source.taskset.id,
-    description: "",
-    instructions,
-    category: "custom",
-    familyNamespace: source.taskset.id,
-    inputSchema: { type: "object" },
-    outputSchema: { type: "object" },
-    rewardBinding: learningRef(input.rewardBinding),
-    harness: null,
-    execution: { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease }
-  }));
-  const derived = compileModelTasksetReward({ ...input, assets: [...assets.values()], source: {
-    taskset: source.taskset,
-    taskDefinition,
-    instructionMode: "per_task",
-    executionResources: { environment: source.environment, verifierSet: source.verifierSet },
-    ...execution ? { execution: execution.execution } : {}
-  } });
-  const files = new Map(source.files.map((file) => [file.asset.id, file]));
-  for (const asset of derived.assets) {
-    let raw = "";
-    for (const byte of new TextEncoder().encode(asset.text)) raw += String.fromCharCode(byte);
-    files.set(asset.id, { asset: asset.asset, base64: btoa(raw) });
-  }
-  const { taskset, executionResources, ...modelResources } = derived;
-  return createTasksetPackage({ schemaVersion: "openpond.tasksetPackage.v1", taskset, ...executionResources, modelResources, files: [...files.values()] });
-}
-
-// src/model-batch-review.ts
-import {
-  LearningDomainError as LearningDomainError2,
-  learningRef as learningRef3,
-  sameLearningRef as sameLearningRef2,
-  requireLearningRelease,
-  requireLearningResource,
-  taskBatchPackageMetadata as taskBatchPackageMetadata2
-} from "@openpond/evals/learning";
-
-// src/model-batch-review-preparation.ts
-import {
-  LearningDomainError,
-  LearningSourceSchema,
-  TaskDefinitionSchema as TaskDefinitionSchema2,
-  TaskEvidenceSchema,
-  TaskFeedbackSchema,
-  assertLearningContentHash,
-  learningEvidenceId,
-  learningRef as learningRef2,
-  sameLearningRef,
-  sealLearningContent as sealLearningContent2,
-  taskBatchPackageMetadata,
-  verifyLearningTextAsset
-} from "@openpond/evals/learning";
-import { compileBoundGraders, createRewardBinding, createRewardRelease, resolveBoundRewards } from "@openpond/evals/rewards";
-function prepareModelBatchReview(input) {
-  const { request, package: value } = input;
-  const learning = value.learningResources;
-  if (!learning) throw new LearningDomainError("model_review_batch_required", 422);
-  const metadata = taskBatchPackageMetadata(value.taskset);
-  const id = `model-review-${contentHash([input.scope, request.modelId, request.operationId])}`;
-  const edits = new Map(request.examples.map((edit) => [contentHash(edit.evidence), edit]));
-  const parentRefs = new Set(learning.evidence.map((evidence2) => contentHash(learningRef2(evidence2))));
-  const decisions = new Map(learning.decisions.map((decision) => [contentHash(decision.evidence), decision]));
-  if (edits.size !== request.examples.length || request.examples.some((edit) => !parentRefs.has(contentHash(edit.evidence)))) {
-    throw new LearningDomainError("model_review_evidence_mismatch", 409);
-  }
-  for (const resource of [input.binding, ...input.rewards, ...input.assets]) assertLearningContentHash(resource);
-  resolveBoundRewards(input.binding, input.rewards);
-  const rewardByHash = /* @__PURE__ */ new Map();
-  for (const source2 of input.binding.sources) {
-    const original = input.rewards.find((reward) => sameLearningRef(learningRef2(reward), source2.reward));
-    const { contentHash: _hash, ...content } = original;
-    rewardByHash.set(original.contentHash, createRewardRelease({ ...content, id: `${id}-reward-${original.contentHash}`, revision: 1 }));
-  }
-  const rewards = [...rewardByHash.values()];
-  const { contentHash: _bindingHash, recipeRef: _recipe, ...bindingContent } = input.binding;
-  const binding = createRewardBinding({
-    ...bindingContent,
-    id: `${id}-binding`,
-    revision: 1,
-    sources: input.binding.sources.map((source2) => ({ ...source2, reward: learningRef2(rewardByHash.get(source2.reward.contentHash)) }))
-  }, rewards);
-  const assetRefs = rewards.flatMap((reward) => [
-    ...reward.assets,
-    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
-    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
-    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
-  ]);
-  const assets = [...new Map(assetRefs.map((ref) => {
-    const asset = input.assets.find((asset2) => asset2.id === ref.id);
-    if (!asset) throw new LearningDomainError("model_review_reward_asset_missing", 422);
-    verifyLearningTextAsset(asset, ref);
-    if (ref.visibility === "policy") throw new LearningDomainError("reward_asset_visibility_invalid", 422);
-    return [asset.id, asset];
-  })).values()];
-  const { environmentRelease: _environment, verifierSetRelease: _verifiers, ...execution } = metadata.definition.execution;
-  const { contentHash: _definitionHash, ...definitionContent } = metadata.definition;
-  const definition = TaskDefinitionSchema2.parse(sealLearningContent2({
-    ...definitionContent,
-    ...request.definition,
-    id: `${id}-definition`,
-    revision: 1,
-    rewardBinding: learningRef2(binding),
-    execution: {
-      ...execution,
-      policy: { ...execution.policy, hiddenGraderRefs: compileBoundGraders(binding, rewards).filter((grader) => grader.privileged).map((grader) => grader.id) }
-    }
-  }));
-  const source = LearningSourceSchema.parse(sealLearningContent2({
-    schemaVersion: "openpond.learningSource.v1",
-    id,
-    revision: 1,
-    name: `${definition.name} review`,
-    kind: "direct",
-    taskDefinition: learningRef2(definition),
-    enabled: true,
-    allowedSplits: [...new Set(learning.evidence.map((item) => item.submission.split))],
-    mapping: null,
-    adapterVersion: null,
-    reviewOrigin: {
-      modelId: request.modelId,
-      packageHash: value.contentHash,
-      taskset: learningRef2(value.taskset),
-      batch: learningRef2(learning.batch),
-      rewardBinding: learningRef2(input.binding)
-    }
-  }));
-  const evidence = learning.evidence.map((parent) => {
-    const edit = edits.get(contentHash(learningRef2(parent)));
-    const attemptId = `review-${parent.contentHash}`;
-    const policyChanged = contentHash({
-      instructions: definition.instructions,
-      inputSchema: definition.inputSchema,
-      outputSchema: definition.outputSchema,
-      requiredOutputs: definition.requiredOutputs ?? [],
-      input: edit?.input ?? parent.submission.input
-    }) !== contentHash({
-      instructions: metadata.definition.instructions,
-      inputSchema: metadata.definition.inputSchema,
-      outputSchema: metadata.definition.outputSchema,
-      requiredOutputs: metadata.definition.requiredOutputs ?? [],
-      input: parent.submission.input
-    });
-    return TaskEvidenceSchema.parse(sealLearningContent2({
-      schemaVersion: "openpond.taskEvidence.v1",
-      id: learningEvidenceId(source.id, parent.submission.exampleId, attemptId),
-      revision: 1,
-      source: learningRef2(source),
-      submission: {
-        ...parent.submission,
-        sourceId: source.id,
-        taskDefinition: learningRef2(definition),
-        attemptId,
-        // The old response was observed under the old policy-visible task. Its
-        // parent snapshot remains available, but it is not a run of new inputs.
-        observedOutput: policyChanged ? null : parent.submission.observedOutput,
-        idempotencyKey: `${id}-${parent.contentHash}`,
-        ...edit?.input === void 0 ? {} : { input: edit.input },
-        ...edit?.expected === void 0 ? {} : { expected: edit.expected },
-        ...edit?.evaluatorContext === void 0 ? {} : { evaluatorContext: edit.evaluatorContext }
-      },
-      supersedes: learningRef2(parent),
-      correctionFeedbackId: null,
-      receivedAt: input.now
-    }));
-  });
-  const proposals = evidence.flatMap((item) => {
-    const edit = edits.get(contentHash(item.supersedes));
-    const decision = decisions.get(contentHash(item.supersedes));
-    const target = edit?.proposedTarget === void 0 ? decision.approvedTarget : edit.proposedTarget;
-    return target === null ? [] : [TaskFeedbackSchema.parse({
-      schemaVersion: "openpond.taskFeedbackRecord.v1",
-      id: `feedback-${contentHash([id, item.id])}`,
-      revision: 1,
-      submission: {
-        schemaVersion: "openpond.taskFeedback.v1",
-        sourceId: source.id,
-        idempotencyKey: `${id}-${item.id}`,
-        exampleId: item.submission.exampleId,
-        attemptId: item.submission.attemptId,
-        expectedEvidenceHash: item.contentHash,
-        occurredAt: input.now,
-        kind: "target_correction",
-        value: target,
-        note: "Proposed target for the revised task. Grade and review before admission."
-      },
-      status: "pending_review",
-      evidence: learningRef2(item),
-      createdAt: input.now,
-      review: null
-    })];
-  });
-  return { source, definition, binding, rewards, assets, evidence, proposals };
-}
-
-// src/model-batch-review.ts
-import { LearningDomainError as LearningDomainError3 } from "@openpond/evals/learning";
-var operation = (request) => `model-batch-review-${contentHash([request.modelId, request.operationId])}`;
-function inspectModelBatchPackage(raw) {
-  const value = validateTasksetPackage(raw);
-  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
-  const metadata = taskBatchPackageMetadata2(value.taskset);
-  return ModelBatchReviewInspectionSchema.parse({
-    schemaVersion: "openpond.modelBatchReviewInspection.v1",
-    packageHash: value.contentHash,
-    definition: metadata.definition,
-    binding: metadata.binding,
-    evidence: value.learningResources.evidence,
-    decisions: value.learningResources.decisions
-  });
-}
-async function findModelBatchReview(transaction, raw) {
-  const request = ModelBatchReviewRequestSchema.parse(raw);
-  const prior = await transaction.operation(operation(request));
-  if (!prior) return null;
-  if (prior.requestHash !== contentHash(request)) throw new LearningDomainError2("learning_idempotency_conflict", 409);
-  return readReceipt(transaction, request, prior.resources);
-}
-async function beginModelBatchReview(transaction, input) {
-  const request = ModelBatchReviewRequestSchema.parse(input.request);
-  const prior = await findModelBatchReview(transaction, request);
-  if (prior) return prior;
-  const value = validateTasksetPackage(input.package);
-  if (!value.learningResources) throw new LearningDomainError2("model_review_batch_required", 422);
-  const metadata = taskBatchPackageMetadata2(value.taskset);
-  const selected = request.rewardBindingRef;
-  const retained = !selected || sameLearningRef2(selected, learningRef3(metadata.binding));
-  const binding = retained ? metadata.binding : await requireLearningRelease(transaction, "binding", selected);
-  const rewards = retained ? metadata.rewards : await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
-  const assetIds = new Set(rewards.flatMap((reward) => [
-    ...reward.assets,
-    ..."verifierRef" in reward.implementation ? [reward.implementation.verifierRef] : [],
-    ..."rubricRef" in reward.implementation ? [reward.implementation.rubricRef] : [],
-    ..."inputContract" in reward.implementation ? [reward.implementation.inputContract] : []
-  ]).map((asset) => asset.id));
-  const assets = retained ? value.learningResources.assets : await Promise.all([...assetIds].map((id) => requireLearningResource(transaction, "asset", id, 1)));
-  const prepared = prepareModelBatchReview({ ...input, request, package: value, binding, rewards, assets });
-  const pointers = [];
-  for (const asset of prepared.assets) {
-    const existing = await transaction.get("asset", asset.id, 1);
-    if (existing && existing.contentHash !== asset.contentHash) throw new LearningDomainError2("model_review_asset_conflict", 409);
-    if (!existing) await transaction.put("asset", asset, 0);
-  }
-  for (const reward of prepared.rewards) await transaction.put("reward", reward, 0);
-  await transaction.put("binding", prepared.binding, 0);
-  await transaction.put("definition", prepared.definition, 0);
-  await transaction.put("source", prepared.source, 0, { parentId: request.modelId });
-  pointers.push({ kind: "source", id: prepared.source.id, revision: 1 });
-  for (const evidence of prepared.evidence) {
-    await transaction.put("evidence", evidence, 0, { parentId: prepared.source.id });
-    pointers.push({ kind: "evidence", id: evidence.id, revision: 1 });
-  }
-  for (const proposal of prepared.proposals) {
-    await transaction.put("feedback", proposal, 0, { parentId: proposal.evidence.id, status: proposal.status });
-    pointers.push({ kind: "feedback", id: proposal.id, revision: 1 });
-  }
-  await transaction.saveOperation(operation(request), { requestHash: contentHash(request), resources: pointers });
-  return readReceipt(transaction, request, pointers);
-}
-async function readReceipt(transaction, request, pointers) {
-  const resources = await Promise.all(pointers.map((pointer) => requireLearningResource(transaction, pointer.kind, pointer.id, pointer.revision)));
-  return ModelBatchReviewReceiptSchema.parse({
-    schemaVersion: "openpond.modelBatchReviewReceipt.v1",
-    operationId: request.operationId,
-    modelId: request.modelId,
-    source: resources.find((resource) => resource.schemaVersion === "openpond.learningSource.v1"),
-    evidence: resources.filter((resource) => resource.schemaVersion === "openpond.taskEvidence.v1"),
-    proposals: resources.filter((resource) => resource.schemaVersion === "openpond.taskFeedbackRecord.v1")
-  });
-}
-
-// src/taskset-package-projection.ts
-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;
-  const resources = value.modelResources;
-  const learning = value.learningResources ? taskBatchPackageMetadata3(release) : void 0;
-  const source = TasksetSourceRefSchema.parse({
-    schemaVersion: "openpond.uploadedFileDatasetSource.v1",
-    kind: "uploaded_file",
-    id: `package-source-${contentHash({ profileId: input.profileId, packageHash: value.contentHash })}`,
-    profileId: input.profileId,
-    title: input.name,
-    sourceHash: value.contentHash,
-    occurredAt: input.createdAt,
-    licensingStatus: "pending",
-    secretScanStatus: "pending",
-    piiScanStatus: "pending",
-    originalFileNames: ["taskset-package.json"],
-    mediaTypes: ["application/json"],
-    sourceFileHashes: [value.contentHash],
-    totalBytes: new TextEncoder().encode(JSON.stringify(value)).byteLength,
-    parserVersion: "openpond.tasksetPackage.v1",
-    metadata: {}
-  });
-  const draft = createTasksetDraft({ profileId: input.profileId, id: `${release.id}-import`, name: input.name, now: input.createdAt });
-  const files = [];
-  for (const grader of release.graders) if (grader.kind === "custom_verifier") {
-    const asset = resources?.assets.find((asset2) => asset2.id === grader.verifierRef.id);
-    const file = value.files.find((file2) => file2.asset.id === grader.verifierRef.id);
-    if (!file) throw new Error(`Imported verifier source is missing: ${grader.id}.`);
-    const name = learningVerifierModule(grader.verifierRef.contentHash);
-    if (!files.some((file2) => file2.path === name)) files.push({ path: name, role: "verifier", content: asset ? verifyLearningTextAsset2(asset, grader.verifierRef) : new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file)) });
-  }
-  const authoring = release.metadata.ordinaryAuthoring ?? release.metadata.starterAuthoring;
-  const fixtures = GraderFixtureSchema.array().max(1e5).parse(authoring?.graderFixtures ?? []);
-  const kind = release.environment.kind === "text" ? "chat" : release.environment.kind === "custom_program" ? "program" : release.environment.kind;
-  const projected = TasksetSchema.parse({
-    schemaVersion: "openpond.taskset.v1",
-    id: release.id,
-    revision: release.revision,
-    profileId: input.profileId,
-    profileRelease: null,
-    createImproveRunId: null,
-    name: input.name,
-    objective: resolveTasksetPackageInstructions(value),
-    status: "needs_review",
-    sourceRefs: [source],
-    datasetArtifact: null,
-    policy: release.policy,
-    environment: {
-      ...draft.environment,
-      kind,
-      entrypoint: release.environment.entrypoint,
-      resources: TasksetEnvironmentResourceSchema.array().max(1e4).parse(release.metadata.environmentResources ?? []),
-      stateful: release.environment.stateful,
-      deterministicSeeds: release.environment.deterministicSeeds,
-      toolNames: release.tools.map((tool) => tool.name),
-      defaultTimeoutMs: release.environment.defaultTimeoutMs,
-      networkPolicy: release.environment.networkPolicy,
-      metadata: {
-        runtimeSourceTasksetId: tasksetPackageSourceId(input.profileId, value.contentHash),
-        portableEnvironment: release.environment,
-        portableTools: release.tools,
-        portableExecutionResources: { environment: value.environment, verifierSet: value.verifierSet }
-      }
-    },
-    capabilities: {
-      ...draft.capabilities,
-      taskKind: kind === "chat" ? "chat" : kind === "program" ? "custom_program" : "single_agent",
-      compatibleMethods: ["none"],
-      requiresTools: release.tools.length > 0,
-      requiresState: release.environment.stateful,
-      rewardKinds: [...new Set(release.graders.map((grader) => grader.kind === "human" ? "human" : grader.kind === "model_judge" ? "model_judge" : "deterministic"))]
-    },
-    tasks: release.tasks.map((task) => ({
-      ...task,
-      schemaVersion: "openpond.taskData.v1",
-      sourceRefs: [source.id],
-      assets: task.artifactRefs.map((asset) => ({
-        id: asset.id,
-        sourceRefId: source.id,
-        artifactRef: asset.path,
-        fileName: asset.path.split("/").at(-1),
-        mediaType: asset.mediaType,
-        sha256: asset.contentHash,
-        sizeBytes: asset.sizeBytes,
-        split: task.split,
-        metadata: { portableAsset: asset }
-      })),
-      ...task.requiredOutputs ? { requiredOutputs: task.requiredOutputs.map((output) => ({
-        ...output,
-        schemaRef: output.schemaRef?.id ?? null,
-        maxBytes: output.maxBytes ?? void 0
-      })) } : {},
-      metadata: { portableTaskRecord: task, exampleOrigin: "imported" }
-    })),
-    graders: resources ? projectLearningBatchGraders(resources.rewardBinding, resources.rewards, resources.assets) : learning ? projectLearningBatchGraders(learning.binding, learning.rewards, value.learningResources.assets) : importedPackageGraders(value),
-    graderFixtures: fixtures,
-    learningSignals: draft.learningSignals,
-    ...release.metrics ? { metrics: release.metrics } : {},
-    authoringProvenance: {
-      schemaVersion: "openpond.taskAuthoringProvenance.v1",
-      model: null,
-      modelConfig: {},
-      skillHash: contentHash("openpond-package-import-v1"),
-      promptTemplateVersion: "package-import-v1",
-      buildIntent: "discovery",
-      buildSpecification: null,
-      evidenceHashes: [value.contentHash],
-      tasksetSdkVersion: "package-import-v1",
-      sourceCommit: null,
-      repairHistory: [],
-      createdAt: input.createdAt
-    },
-    readiness: null,
-    contentHash: "00000000",
-    createdAt: input.createdAt,
-    updatedAt: input.createdAt,
-    metadata: {
-      importedPackageHash: value.contentHash,
-      ...learning ? { learning } : {},
-      portableFileInventory: value.files.map((file) => ({ asset: file.asset, sourcePath: file.asset.path })),
-      ...resources ? {
-        taskDefinition: learningRef4(resources.taskDefinition),
-        rewardBinding: learningRef4(resources.rewardBinding),
-        rewardExecution: { binding: resources.rewardBinding, rewards: resources.rewards }
-      } : {},
-      portableCapabilities: release.capabilities,
-      derivedPortableMetadata: release.metadata,
-      ...release.metadata.modelTasksetDerivation ? { modelTasksetDerivation: release.metadata.modelTasksetDerivation } : {}
-    }
-  });
-  return { package: value, taskset: TasksetSchema.parse({ ...projected, contentHash: computeTasksetHash(projected) }), generatedFiles: files };
-}
-function tasksetPackageSourceId(profileId, packageHash) {
-  return `package-${contentHash({ profileId, packageHash })}`;
-}
-
-// src/taskset-draft-source.ts
-import { z } from "zod";
-import { learningRef as learningRef5, sameLearningRef as sameLearningRef3 } from "@openpond/evals/learning";
-var TasksetDraftSourceInitializationSchema = z.object({
-  draft: TasksetDraftSchema,
-  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 || !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 ?? []);
-  const sourcePath = (relative) => isManagedTasksetDraftFilePath(relative) ? `source-artifacts/${source.contentHash}/${contentHash(relative)}/${relative.split("/").at(-1)}` : relative;
-  const references = [
-    ...original.tasks.flatMap((task) => (task.assets ?? []).map((asset) => asset.artifactRef)),
-    ...(original.environment.resources ?? []).map((resource) => resource.path),
-    ...source.taskset.tasks.flatMap((task) => (task.requiredOutputs ?? []).flatMap((output) => output.schemaRef ? [output.schemaRef.path] : [])),
-    ...original.metrics.customAggregator ? [original.metrics.customAggregator.module] : [],
-    ...original.graders.flatMap((grader) => grader.kind === "custom_verifier" ? [grader.module] : [])
-  ];
-  if (references.some(isManagedTasksetDraftFilePath)) throw new Error("A referenced source asset occupies a reserved Taskset authoring path.");
-  const filePaths = source.files.map((file) => {
-    const paths = /* @__PURE__ */ new Set([file.asset.path]);
-    for (const entry of inventory) if (entry.asset.id === file.asset.id) paths.add(entry.sourcePath);
-    for (const task of original.tasks) for (const asset of task.assets ?? []) if (asset.id === file.asset.id) paths.add(asset.artifactRef);
-    for (const grader of source.taskset.graders) if (grader.kind === "custom_verifier" && grader.verifierRef.id === file.asset.id) {
-      const projected = original.graders.find((candidate) => candidate.id === grader.id);
-      if (projected?.kind === "custom_verifier") paths.add(projected.module);
-    }
-    return { assetId: file.asset.id, paths: [...paths].map(sourcePath) };
-  });
-  const metadata = { ...original.metadata };
-  if (source.modelResources) for (const key of ["taskDefinition", "rewardBinding", "rewardExecution", "derivedPortableMetadata", "modelTasksetDerivation", "importedPackageHash"]) delete metadata[key];
-  const draft = TasksetDraftSchema.parse({
-    ...original,
-    id: preparation.draftId,
-    revision: 1,
-    status: "draft",
-    graders: original.graders.map((grader) => ({ ...grader, metadata: {
-      ...grader.metadata,
-      portableGrader: source.taskset.graders.find((candidate) => candidate.id === grader.id)
-    } })),
-    environment: { ...original.environment, metadata: { ...original.environment.metadata, portableExecutionResources: { environment: source.environment } } },
-    modelScope: { modelId: preparation.lineage.owner.modelId, expectedModelRevision: input.expectedModelRevision, source: preparation },
-    publishedTasksetRef: preparation.tasksetRevision > 1 ? preparation.sourceTasksetRef : null,
-    metadata: {
-      ...metadata,
-      modelTasksetAuthoring: preparation.lineage,
-      portableFileInventory: inventory.map((entry) => ({ ...entry, sourcePath: sourcePath(entry.sourcePath), asset: {
-        ...entry.asset,
-        id: isManagedTasksetDraftFilePath(entry.sourcePath) ? `source-artifact-${contentHash({ packageHash: source.contentHash, assetId: entry.asset.id })}` : entry.asset.id,
-        path: sourcePath(entry.asset.path)
-      } }))
-    }
-  });
-  return TasksetDraftSourceInitializationSchema.parse({ draft, filePaths });
-}
-function materializeTasksetDraftWorkspace(input) {
-  const initialized = TasksetDraftSourceInitializationSchema.parse(input.initialized);
-  const source = validateTasksetPackage(input.source);
-  if (initialized.draft.modelScope?.source?.sourcePackageHash !== source.contentHash) throw new Error("Taskset draft lost its source preparation.");
-  const files = /* @__PURE__ */ new Map();
-  for (const mapping of initialized.filePaths) {
-    const file = source.files.find((candidate) => candidate.asset.id === mapping.assetId);
-    if (!file) throw new Error("Taskset draft source asset is missing.");
-    for (const path of mapping.paths) {
-      const previous = files.get(path);
-      if (previous && previous.contentHash !== file.asset.contentHash) throw new Error("Taskset draft source paths conflict.");
-      files.set(path, { path, contentHash: file.asset.contentHash, sizeBytes: file.asset.sizeBytes, base64: file.base64 });
-    }
-  }
-  for (const configured of configuredTasksetDraftFiles(initialized.draft)) if (!files.has(configured.relativePath)) {
-    const bytes = new TextEncoder().encode(configured.source);
-    files.set(configured.relativePath, { path: configured.relativePath, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: Buffer.from(bytes).toString("base64") });
-  }
-  let draft = initialized.draft;
-  if (draft.metrics.customAggregator) {
-    const file = files.get(draft.metrics.customAggregator.module);
-    if (!file) throw new Error("Declared Taskset metric module is missing.");
-    decodeTasksetDraftWorkspaceFile(file);
-    draft = TasksetDraftSchema.parse({ ...draft, metrics: { ...draft.metrics, customAggregator: { ...draft.metrics.customAggregator, contentHash: file.contentHash } } });
-  }
-  return createTasksetDraftWorkspace({ schemaVersion: "openpond.tasksetDraftWorkspace.v1", draft, files: [...files.values()] });
-}
+import "./chunk-I2MBVOVX.js";
+import "./chunk-QUOW6URQ.js";
 export {
   AuthoredTasksetFileInventorySchema,
   MAX_TASKSET_PACKAGE_BYTES,
-  LearningDomainError3 as ModelBatchReviewError,
+  LearningDomainError as ModelBatchReviewError,
   ModelBatchReviewInspectionSchema,
   ModelBatchReviewReceiptSchema,
   ModelBatchReviewRequestSchema,
@@ -640,6 +111,7 @@ export {
   TasksetPackageReadbackSchema,
   TasksetPackageReceiptSchema,
   TasksetPackageSchema,
+  TasksetReleasePackageReadbackSchema,
   beginModelBatchReview,
   bindOrdinaryModelTasksetReward,
   compileModelTasksetDraftWorkspace,