openpond-sdk 0.9.9 → 0.11.0

package/dist/chunk-HOAYWW33.js

@@ -0,0 +1,587 @@
+import {
+  ModelBatchReviewInspectionSchema,
+  ModelBatchReviewReceiptSchema,
+  ModelBatchReviewRequestSchema
+} from "./chunk-YVUIHH6Z.js";
+import {
+  importedPackageGraders,
+  learningVerifierModule,
+  projectLearningBatchGraders
+} from "./chunk-NHCGOFQW.js";
+import {
+  AuthoredTasksetFileInventorySchema
+} from "./chunk-IXBSFJCX.js";
+import {
+  TasksetDraftSchema,
+  configuredTasksetDraftFiles,
+  createTasksetDraft,
+  createTasksetDraftWorkspace,
+  decodeTasksetDraftWorkspaceFile,
+  isManagedTasksetDraftFilePath
+} from "./chunk-R3M6BIOK.js";
+import {
+  GraderFixtureSchema,
+  TasksetEnvironmentResourceSchema,
+  TasksetSchema,
+  TasksetSourceRefSchema,
+  computeTasksetHash
+} from "./chunk-XJDWHTH5.js";
+import {
+  compileModelTasksetReward,
+  createTasksetPackage,
+  decodeTasksetPackageFile,
+  resolveTasksetPackageExecution,
+  resolveTasksetPackageInstructions,
+  validateTasksetPackage
+} from "./chunk-JA3KFK3U.js";
+import {
+  ModelTasksetDraftPreparationSchema,
+  TasksetDraftFilePathSchema
+} from "./chunk-2U54EOXJ.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()] });
+}
+
+export {
+  bindOrdinaryModelTasksetReward,
+  inspectModelBatchPackage,
+  findModelBatchReview,
+  beginModelBatchReview,
+  LearningDomainError3 as LearningDomainError,
+  prepareImportedTasksetPackage,
+  tasksetPackageSourceId,
+  TasksetDraftSourceInitializationSchema,
+  prepareTasksetDraftSource,
+  materializeTasksetDraftWorkspace
+};
+//# sourceMappingURL=chunk-HOAYWW33.js.map