openpond-sdk 0.6.7 → 0.8.0

package/dist/chunk-DNBAJUVR.js

@@ -0,0 +1,380 @@
+import {
+  decodeTasksetDraftWorkspaceFile,
+  publishTasksetDraft,
+  renderTasksetDraftManifests,
+  validateTasksetDraftWorkspace
+} from "./chunk-32H2EJRA.js";
+import {
+  materializePortableTasksetRelease,
+  portableTasksetEnvironment,
+  projectPortableTaskRecord
+} from "./chunk-DT7FRNIZ.js";
+import {
+  TasksetSchema,
+  computeTasksetHash
+} from "./chunk-LGEF4S5I.js";
+import {
+  MAX_TASKSET_PACKAGE_BYTES,
+  ModelStarterExecutionSchema,
+  ModelTasksetDerivationSchema,
+  assertModelTasksetAuthoring,
+  compileModelTasksetReward,
+  createTasksetPackage,
+  createTasksetPackageExecutionFile,
+  decodeTasksetPackageFile,
+  deriveModelTaskset,
+  modelAuthoredTasksetId,
+  modelStarterExecutionAssetId,
+  resolveTasksetPackageExecution,
+  resolveTasksetPackageInstructions,
+  validateTasksetPackage
+} from "./chunk-WOPM32SE.js";
+import {
+  ModelTasksetAuthoringOwnerSchema,
+  ModelTasksetDraftPreparationSchema,
+  ModelTasksetDraftRequestSchema,
+  TasksetDraftFilePathSchema
+} from "./chunk-2U54EOXJ.js";
+import {
+  ImmutableAssetRefSchema,
+  contentHash,
+  sha256
+} from "./chunk-QUOW6URQ.js";
+
+// src/model-taskset-authoring.ts
+import { createVerifierSetRelease } from "@openpond/evals";
+import { learningRef as learningRef2, sameLearningRef as sameLearningRef2, sealLearningContent as sealLearningContent2 } from "@openpond/evals/learning";
+import { TasksetReleaseSchema as TasksetReleaseSchema2 } from "@openpond/evals/tasksets";
+
+// src/model-bound-taskset-authoring.ts
+import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sameLearningRef, sealLearningContent } 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 || !sameLearningRef(learningRef(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, LearningTextAssetSchema.parse(sealLearningContent({ 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 = TaskDefinitionSchema.parse(sealLearningContent({
+    ...definitionContent,
+    instructions,
+    execution: { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease }
+  }));
+  const { contentHash: _taskHash, ...taskContent } = edited.taskset;
+  const taskset = TasksetReleaseSchema.parse(sealLearningContent({ ...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: learningRef2(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 : learningRef2(source.taskset);
+  const lineage = { schemaVersion: "openpond.modelTasksetAuthoring.v1", owner, root, parent: learningRef2(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: learningRef2(source.taskset),
+    tasksetId: modelAuthoredTasksetId(lineage),
+    tasksetRevision: owned ? source.taskset.revision + 1 : 1,
+    lineage
+  });
+}
+function publishModelTasksetDraftPackage(input) {
+  const prepared = ModelTasksetDraftPreparationSchema.parse(input.preparation);
+  if (!sameLearningRef2(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: learningRef2(edited.verifierSet) }
+  });
+  const { contentHash: _hash, ...content } = edited.taskset;
+  const taskset = TasksetReleaseSchema2.parse(sealLearningContent2({
+    ...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-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 learningRef3, sealLearningContent as sealLearningContent3 } 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(sealLearningContent3({
+    ...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: learningRef3(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 compileTasksetDraftWorkspace(input) {
+  const workspace = validateTasksetDraftWorkspace(input.workspace);
+  const preparation = input.preparation === null ? null : ModelTasksetDraftPreparationSchema.parse(input.preparation);
+  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;
+}
+function compileModelTasksetDraftWorkspace(input) {
+  if (!input.workspace.draft.modelScope) throw new Error("Taskset draft requires a Model owner.");
+  return compileTasksetDraftWorkspace(input);
+}
+
+export {
+  prepareModelTasksetDraft,
+  publishModelTasksetDraftPackage,
+  AuthoredTasksetFileInventorySchema,
+  isGeneratedTasksetPublicationFilePath,
+  prepareAuthoredTasksetSource,
+  compileTasksetDraftWorkspace,
+  compileModelTasksetDraftWorkspace
+};
+//# sourceMappingURL=chunk-DNBAJUVR.js.map

package/dist/chunk-DNBAJUVR.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/model-taskset-authoring.ts", "../src/model-bound-taskset-authoring.ts", "../src/taskset-authored-files.ts", "../src/taskset-authored-tool-environment.ts", "../src/taskset-draft-package-compiler.ts"],
+  "sourcesContent": ["import { contentHash } from \"@openpond/harness\";\nimport { createVerifierSetRelease } from \"@openpond/evals\";\nimport { learningRef, sameLearningRef, sealLearningContent } from \"@openpond/evals/learning\";\nimport { TasksetReleaseSchema } from \"@openpond/evals/tasksets\";\nimport { ModelTasksetAuthoringOwnerSchema, ModelTasksetDraftPreparationSchema, ModelTasksetDraftRequestSchema, type ModelTasksetDraftPreparation, type ModelTasksetDraftRequest } from \"./model-taskset-authoring-contracts.js\";\nimport { assertModelTasksetAuthoring, modelAuthoredTasksetId } from \"./model-taskset-authoring-lineage.js\";\nimport { createTasksetPackage, validateTasksetPackage, type TasksetPackage } from \"./taskset-package-contracts.js\";\nimport { createTasksetPackageExecutionFile, resolveTasksetPackageExecution } from \"./taskset-package-execution.js\";\nimport { modelStarterExecutionAssetId } from \"./model-starter-execution.js\";\nimport { deriveModelTaskset } from \"./model-taskset-derivation.js\";\nimport { publishBoundModelTasksetDraftPackage } from \"./model-bound-taskset-authoring.js\";\n\nexport * from \"./model-taskset-authoring-contracts.js\";\n\n/** Resolve under an authorized Model CAS. The host retains requestHash and the\n * preparation so retrying cannot choose newer source bytes or another draft. */\nexport function prepareModelTasksetDraft(input: { request: ModelTasksetDraftRequest; owner: { scopeId: string; modelId: string }; source: TasksetPackage }): ModelTasksetDraftPreparation {\n  const request = ModelTasksetDraftRequestSchema.parse(input.request);\n  const owner = ModelTasksetAuthoringOwnerSchema.parse(input.owner);\n  const source = validateTasksetPackage(input.source);\n  if (source.learningResources) throw new Error(\"Reviewed Tasksets require their reviewed authoring workflow.\");\n  if (source.contentHash !== request.sourcePackageHash) throw new Error(\"Taskset draft source package changed.\");\n  if (source.modelResources) {\n    const derived = deriveModelTaskset({ owner, source: { ...source.modelResources, taskset: source.taskset, executionResources: { environment: source.environment, verifierSet: source.verifierSet } },\n      rewardBinding: source.modelResources.rewardBinding, rewards: source.modelResources.rewards, assets: source.modelResources.assets });\n    const lineage = derived.taskset.metadata.modelTasksetDerivation as { owner: typeof owner; root: ReturnType<typeof learningRef>; parent: ReturnType<typeof learningRef> };\n    return ModelTasksetDraftPreparationSchema.parse({ schemaVersion: \"openpond.modelTasksetDraftPreparation.v1\",\n      draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`, requestHash: contentHash(request),\n      sourcePackageHash: source.contentHash, sourceTasksetRef: learningRef(source.taskset), tasksetId: derived.taskset.id,\n      tasksetRevision: derived.taskset.revision, lineage: { ...lineage, schemaVersion: \"openpond.modelTasksetAuthoring.v1\" }, authoringGraph: \"bound\",\n    });\n  }\n  const previous = assertModelTasksetAuthoring(source.taskset);\n  const owned = previous && contentHash(previous.owner) === contentHash(owner);\n  const root = owned ? previous.root : learningRef(source.taskset);\n  const lineage = { schemaVersion: \"openpond.modelTasksetAuthoring.v1\" as const, owner, root, parent: learningRef(source.taskset) };\n  return ModelTasksetDraftPreparationSchema.parse({\n    schemaVersion: \"openpond.modelTasksetDraftPreparation.v1\",\n    draftId: `model-taskset-draft-${contentHash({ owner, operationId: request.operationId })}`,\n    requestHash: contentHash(request), sourcePackageHash: source.contentHash, sourceTasksetRef: learningRef(source.taskset),\n    tasksetId: modelAuthoredTasksetId(lineage), tasksetRevision: owned ? source.taskset.revision + 1 : 1, lineage,\n  });\n}\n\n/** The edited package already carries exact file bytes and execution releases.\n * Seal the owned revision without copying qualification for different bytes. */\nexport function publishModelTasksetDraftPackage(input: { preparation: ModelTasksetDraftPreparation; edited: TasksetPackage; source?: TasksetPackage }): TasksetPackage {\n  const prepared = ModelTasksetDraftPreparationSchema.parse(input.preparation);\n  if (!sameLearningRef(prepared.sourceTasksetRef, prepared.lineage.parent)) throw new Error(\"Taskset draft preparation differs from its source lineage.\");\n  if (prepared.authoringGraph === \"bound\") {\n    if (!input.source) throw new Error(\"Bound Taskset authoring requires its retained source package.\");\n    return publishBoundModelTasksetDraftPackage({ preparation: prepared, source: input.source, edited: input.edited });\n  }\n  const edited = requireOrdinaryPackage(input.edited);\n  const { contentHash: _verifierHash, ...verifierContent } = edited.verifierSet;\n  const verifierSet = createVerifierSetRelease({ ...verifierContent, id: `${prepared.tasksetId}-verifiers`, revision: prepared.tasksetRevision,\n    calibrationReceiptRefs: [], metadata: { sourceVerifierSet: learningRef(edited.verifierSet) } });\n  const { contentHash: _hash, ...content } = edited.taskset;\n  const taskset = TasksetReleaseSchema.parse(sealLearningContent({ ...content, id: prepared.tasksetId, revision: prepared.tasksetRevision,\n    verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash },\n    metadata: {\n      modelTasksetAuthoring: prepared.lineage,\n      ...(edited.taskset.metadata.environmentResources === undefined ? {} : { environmentResources: edited.taskset.metadata.environmentResources }),\n      ...(edited.taskset.metadata.ordinaryAuthoring === undefined ? {} : { ordinaryAuthoring: edited.taskset.metadata.ordinaryAuthoring }),\n    },\n  }));\n  const resolved = resolveTasksetPackageExecution(edited);\n  const files = resolved ? [\n    ...edited.files.filter(file => file.asset.id !== modelStarterExecutionAssetId(edited.taskset)),\n    createTasksetPackageExecutionFile({ ...resolved.execution, verifierSet }),\n  ] : edited.files;\n  return createTasksetPackage({ schemaVersion: \"openpond.tasksetPackage.v1\", taskset, environment: edited.environment, verifierSet, files });\n}\n\nfunction requireOrdinaryPackage(value: unknown) {\n  const result = validateTasksetPackage(value);\n  if (result.modelResources || result.learningResources) throw new Error(\"This Taskset requires its bound or reviewed authoring workflow.\");\n  return result;\n}\n", "import { contentHash } from \"@openpond/harness\";\nimport { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sameLearningRef, sealLearningContent } from \"@openpond/evals/learning\";\nimport { TasksetReleaseSchema } from \"@openpond/evals/tasksets\";\nimport { ModelTasksetDerivationSchema, compileModelTasksetReward } from \"./model-taskset-derivation.js\";\nimport type { ModelTasksetDraftPreparation } from \"./model-taskset-authoring-contracts.js\";\nimport { createTasksetPackage, decodeTasksetPackageFile, resolveTasksetPackageInstructions, validateTasksetPackage, type TasksetPackage } from \"./taskset-package-contracts.js\";\nimport { resolveTasksetPackageExecution } from \"./taskset-package-execution.js\";\n\n/** Task edits retain the exact saved Reward. Changing its implementation or\n * grading policy goes through Reward publication and Model selection. */\nexport function publishBoundModelTasksetDraftPackage(input: {\n  preparation: ModelTasksetDraftPreparation; source: TasksetPackage; edited: TasksetPackage;\n}): TasksetPackage {\n  const source = validateTasksetPackage(input.source);\n  const edited = validateTasksetPackage(input.edited);\n  const prepared = input.preparation;\n  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.\");\n  if (source.contentHash !== prepared.sourcePackageHash || !sameLearningRef(learningRef(source.taskset), prepared.sourceTasksetRef)) throw new Error(\"Bound draft differs from its retained source package.\");\n  const normalizedGraders = (value: TasksetPackage) => value.taskset.graders.map(grader => grader.kind === \"custom_verifier\" ? { ...grader, exportName: grader.exportName ?? \"verify\" } : grader);\n  if (contentHash(normalizedGraders(source)) !== contentHash(normalizedGraders(edited))) throw new Error(\"Edit the saved Reward in Rewards before changing this Taskset's graders.\");\n  const resources = source.modelResources;\n  const assets = new Map(resources.assets.map(asset => [asset.id, asset]));\n  const execution = resolveTasksetPackageExecution(edited);\n  const sourceExecution = resolveTasksetPackageExecution(source);\n  const environmentContent = (value: TasksetPackage[\"environment\"]) => {\n    const { id: _id, revision: _revision, contentHash: _hash, metadata, ...contract } = value;\n    const { javascriptEnvironment: _javascript, ...retained } = metadata;\n    return { ...contract, metadata: { ...retained, resources: retained.resources ?? [] } };\n  };\n  const javascriptContent = (value: typeof execution) => {\n    if (!value) return null;\n    const { id: _id, revision: _revision, contentHash: _hash, ...contract } = value.execution.javascript;\n    return contract;\n  };\n  const unchangedEnvironment = contentHash(environmentContent(source.environment)) === contentHash(environmentContent(edited.environment))\n    && contentHash(javascriptContent(sourceExecution)) === contentHash(javascriptContent(execution));\n  const selectedEnvironment = unchangedEnvironment ? source.environment : edited.environment;\n  const selectedExecution = unchangedEnvironment ? sourceExecution : execution;\n  const requiredIds = new Set([\n    ...resources.assets.map(asset => asset.id),\n    ...edited.taskset.tasks.flatMap(task => task.privilegedContextRef ? [task.privilegedContextRef] : []),\n    ...[edited.environment.actionSchemaRef, edited.environment.observationSchemaRef, edited.environment.stateSchemaRef].flatMap(ref => ref ? [ref.id] : []),\n    ...(execution?.assets.map(asset => asset.id) ?? []),\n  ]);\n  for (const id of requiredIds) {\n    const file = edited.files.find(file => file.asset.id === id);\n    if (!file) throw new Error(`Bound Taskset asset is missing: ${id}.`);\n    const text = new TextDecoder(\"utf-8\", { fatal: true }).decode(decodeTasksetPackageFile(file));\n    assets.set(id, LearningTextAssetSchema.parse(sealLearningContent({ schemaVersion: \"openpond.learningTextAsset.v1\", id, revision: 1, asset: file.asset, text })));\n  }\n  const instructions = resolveTasksetPackageInstructions(edited);\n  const { contentHash: _definitionHash, ...definitionContent } = resources.taskDefinition;\n  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = edited.taskset;\n  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent({ ...definitionContent, instructions,\n    execution: { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease },\n  }));\n  const { contentHash: _taskHash, ...taskContent } = edited.taskset;\n  const taskset = TasksetReleaseSchema.parse(sealLearningContent({ ...taskContent, tasks: edited.taskset.tasks.map(task => resources.instructionMode === \"per_task\" ? task\n    : { ...task, policyVisibleContext: { ...task.policyVisibleContext, instructions } }) }));\n  const derived = compileModelTasksetReward({ owner: prepared.lineage.owner,\n    source: { ...resources, taskset: source.taskset, executionResources: { environment: source.environment, verifierSet: source.verifierSet } },\n    rewardBinding: resources.rewardBinding, rewards: resources.rewards, assets: [...assets.values()],\n    edits: { taskset, taskDefinition, executionResources: { environment: selectedEnvironment, verifierSet: edited.verifierSet }, ...(selectedExecution ? { execution: selectedExecution.execution } : {}) },\n  });\n  const lineage = ModelTasksetDerivationSchema.parse(derived.taskset.metadata.modelTasksetDerivation);\n  if (derived.taskset.id !== prepared.tasksetId || derived.taskset.revision !== prepared.tasksetRevision\n    || contentHash({ ...lineage, schemaVersion: prepared.lineage.schemaVersion }) !== contentHash(prepared.lineage)) throw new Error(\"Bound draft differs from its retained ownership lineage.\");\n  const { taskset: published, executionResources, ...modelResources } = derived;\n  return createTasksetPackage({ schemaVersion: \"openpond.tasksetPackage.v1\", taskset: published, ...executionResources!, modelResources, files: edited.files });\n}\n", "import { z } from \"zod\";\nimport { contentHash, ImmutableAssetRefSchema, sha256, type ImmutableAssetRef } from \"@openpond/harness\";\nimport { TasksetSchema, type GeneratedTaskFile, type Taskset } from \"./taskset-authored-contracts.js\";\nimport { computeTasksetHash } from \"./taskset-authored-validation.js\";\nimport { projectPortableTaskRecord } from \"./taskset-authored-portable-release.js\";\nimport { TasksetDraftFilePathSchema } from \"./model-taskset-authoring-contracts.js\";\nimport { MAX_TASKSET_PACKAGE_BYTES } from \"./taskset-package-files.js\";\nimport { prepareAuthoredToolEnvironment } from \"./taskset-authored-tool-environment.js\";\n\nexport const AuthoredTasksetFileInventorySchema = z.array(z.object({\n  asset: ImmutableAssetRefSchema, sourcePath: z.string().min(1),\n}).strict()).max(10_000);\n\nconst GENERATED_MANIFESTS = new Set([\"taskset.json\", \"capabilities.json\", \"data/tasks.jsonl\", \"graders/graders.json\", \"fixtures/grader-fixtures.json\", \"environment/taskset.ts\"]);\nexport function isGeneratedTasksetPublicationFilePath(path: string): boolean { return GENERATED_MANIFESTS.has(path); }\n\n/** Seal one captured file population; hosts own filesystem or object-store capture. */\nexport function prepareAuthoredTasksetSource(tasksetInput: Taskset, sourceFiles: ReadonlyMap<string, Uint8Array>, adapterId: string) {\n  const taskset = TasksetSchema.parse(tasksetInput);\n  if (taskset.metadata.taskDefinition !== undefined || taskset.metadata.rewardBinding !== undefined) return { taskset, generatedFiles: [] as GeneratedTaskFile[] };\n  const bytes = new Map<string, Uint8Array>();\n  let total = 0;\n  for (const [name, data] of sourceFiles) {\n    TasksetDraftFilePathSchema.parse(name);\n    total += data.byteLength;\n    if (bytes.size >= 10_000 || total > MAX_TASKSET_PACKAGE_BYTES * 3 / 4) throw new Error(\"Taskset source exceeds the package byte limit.\");\n    bytes.set(name, data.slice());\n  }\n  const aggregator = taskset.metrics?.customAggregator;\n  const aggregatorBytes = aggregator ? bytes.get(aggregator.module) : undefined;\n  if (aggregator && !aggregatorBytes) throw new Error(\"Declared Taskset metric module is missing.\");\n  const metrics = aggregator && aggregatorBytes ? { ...taskset.metrics!, customAggregator: { ...aggregator, contentHash: sha256(aggregatorBytes) } } : taskset.metrics;\n  const inventory = new Map<string, { asset: ImmutableAssetRef; sourcePath: string }>();\n  const declaredPaths = new Set<string>();\n  const generatedFiles: GeneratedTaskFile[] = [];\n  const ref = (id: string, sourcePath: string, mediaType: string, visibility: ImmutableAssetRef[\"visibility\"]): ImmutableAssetRef => {\n    const source = bytes.get(sourcePath);\n    if (!source) throw new Error(`Declared Taskset file is missing: ${sourcePath}.`);\n    return { id, path: sourcePath, contentHash: sha256(source), sizeBytes: source.byteLength, mediaType, visibility };\n  };\n  const add = (asset: ImmutableAssetRef, sourcePath = asset.path) => {\n    const previous = inventory.get(asset.id);\n    if (previous && contentHash(previous) !== contentHash({ asset, sourcePath })) throw new Error(`Conflicting Taskset file identity: ${asset.id}.`);\n    const source = bytes.get(sourcePath);\n    if (!source || source.length !== asset.sizeBytes || sha256(source) !== asset.contentHash) throw new Error(`Taskset file differs from its declared bytes: ${asset.id}.`);\n    inventory.set(asset.id, { asset, sourcePath });\n    declaredPaths.add(sourcePath);\n  };\n  for (const task of taskset.tasks) {\n    const portable = projectPortableTaskRecord(task);\n    for (const asset of portable.artifactRefs) add(asset, task.assets?.find(candidate => candidate.id === asset.id)?.artifactRef ?? asset.path);\n    for (const output of portable.requiredOutputs ?? []) if (output.schemaRef) add(output.schemaRef);\n  }\n  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\"));\n  const graders = taskset.graders.map(grader => {\n    if (grader.kind === \"custom_verifier\") {\n      let asset = ref(`verifier-${grader.id}`, grader.module, \"application/javascript\", \"host_private\");\n      const previous = ImmutableAssetRefSchema.safeParse(grader.metadata.portableVerifierRef);\n      if (previous.success && previous.data.contentHash === asset.contentHash && previous.data.sizeBytes === asset.sizeBytes) asset = previous.data;\n      add(asset, grader.module);\n      return { ...grader, metadata: { ...grader.metadata, portableVerifierRef: asset } };\n    }\n    if (grader.kind === \"human\" || grader.kind === \"model_judge\") {\n      const content = new TextEncoder().encode(grader.rubric);\n      const sourcePath = `graders/rubric-${sha256(content)}.md`;\n      bytes.set(sourcePath, content);\n      const asset = ref(`rubric-${grader.id}`, sourcePath, \"text/markdown\", \"verifier\");\n      add(asset);\n      generatedFiles.push({ path: sourcePath, role: \"verifier\", content: grader.rubric });\n      return { ...grader, metadata: { ...grader.metadata, portableRubricRef: asset } };\n    }\n    return grader;\n  });\n  if (aggregator && ![...inventory.values()].some(file => file.asset.path === aggregator.module && file.sourcePath === aggregator.module && file.asset.visibility !== \"policy\")) {\n    add(ref(`metric-${contentHash(aggregator.module)}`, aggregator.module, \"application/javascript\", \"host_private\"));\n  }\n  // Unreferenced source files are retained privately. Only explicit task or\n  // environment declarations can make bytes visible to the policy.\n  const previousInventory = AuthoredTasksetFileInventorySchema.parse(taskset.metadata.portableFileInventory ?? []);\n  for (const name of [...bytes.keys()].sort()) if (!declaredPaths.has(name)) {\n    const previous = previousInventory.find(file => file.sourcePath === name && !inventory.has(file.asset.id));\n    add(previous\n      ? { ...ref(previous.asset.id, name, previous.asset.mediaType, previous.asset.visibility), path: previous.asset.path }\n      : ref(`taskset-file-${contentHash(name)}`, name, \"application/octet-stream\", \"host_private\"), name);\n  }\n  // Publication creates a new release; imported cache and execution identities\n  // describe the source revision, not the newly edited graders.\n  const { importedPackageHash, derivedPortableMetadata: _derived, ...metadata } = taskset.metadata;\n  const environmentMetadata = { ...taskset.environment.metadata };\n  if (environmentMetadata.portableExecutionResources !== undefined) {\n    const resources = z.object({ environment: z.unknown(), verifierSet: z.unknown().optional() }).parse(environmentMetadata.portableExecutionResources);\n    environmentMetadata.portableExecutionResources = { environment: resources.environment };\n  }\n  const prepared = TasksetSchema.parse({ ...taskset, graders, metrics,\n    environment: { ...taskset.environment, metadata: environmentMetadata },\n    metadata: { ...metadata, ...(importedPackageHash === undefined ? {} : { sourceImportedPackageHash: importedPackageHash }), portableFileInventory: AuthoredTasksetFileInventorySchema.parse([...inventory.values()].sort((left, right) => left.asset.id.localeCompare(right.asset.id))) } });\n  const executable = prepareAuthoredToolEnvironment(prepared, bytes, [...inventory.values()], adapterId);\n  return { taskset: TasksetSchema.parse({ ...executable.taskset, contentHash: computeTasksetHash(executable.taskset) }), generatedFiles: [...generatedFiles, ...executable.generatedFiles] };\n}\n", "import { TasksetSchema, type GeneratedTaskFile, type Taskset } from \"./taskset-authored-contracts.js\";\nimport { createEnvironmentRelease } from \"@openpond/evals\";\nimport { JavaScriptEnvironmentDefinitionSchema } from \"@openpond/evals/javascript-environment\";\nimport { learningRef, sealLearningContent } from \"@openpond/evals/learning\";\nimport { contentHash, type ImmutableAssetRef } from \"@openpond/harness\";\nimport { computeTasksetHash } from \"./taskset-authored-validation.js\";\nimport { materializePortableTasksetRelease, portableTasksetEnvironment } from \"./taskset-authored-portable-release.js\";\nimport { ModelStarterExecutionSchema } from \"./model-starter-execution.js\";\nimport { createTasksetPackageExecutionFile } from \"./taskset-package-execution.js\";\nimport { decodeTasksetPackageFile } from \"./taskset-package-files.js\";\n\ntype Inventory = Array<{ asset: ImmutableAssetRef; sourcePath: string }>;\n\n/** Source bytes change in the draft; publication owns all executable hashes.\n * The private declaration is regenerated with the newly compiled verifiers. */\nexport function prepareAuthoredToolEnvironment(taskset: Taskset, bytes: Map<string, Uint8Array>, inventory: Inventory, adapterId: string): { taskset: Taskset; inventory: Inventory; generatedFiles: GeneratedTaskFile[] } {\n  if (taskset.environment.entrypoint !== \"openpond.javascript-environment.v1\") return { taskset, inventory, generatedFiles: [] };\n  const declarationPath = \"environment/execution.json\";\n  const declaration = bytes.get(declarationPath);\n  if (!declaration || declaration.length > 524_288) throw new Error(\"Authored tool environment requires its bounded private execution declaration.\");\n  const previous = ModelStarterExecutionSchema.parse(JSON.parse(new TextDecoder(\"utf-8\", { fatal: true }).decode(declaration)));\n  const repin = (ref: ImmutableAssetRef | null): ImmutableAssetRef | null => {\n    if (!ref) return null;\n    const file = inventory.find(file => file.asset.id === ref.id && file.asset.path === ref.path);\n    if (!file) throw new Error(`Authored environment dependency is missing: ${ref.id}.`);\n    return file.asset;\n  };\n  const { contentHash: _javascriptHash, ...javascriptContent } = previous.javascript;\n  const javascript = JavaScriptEnvironmentDefinitionSchema.parse(sealLearningContent({ ...javascriptContent,\n    id: `javascript-${taskset.id}`, revision: taskset.revision, module: repin(previous.javascript.module),\n  }));\n  if (contentHash(javascript.tools) !== contentHash(taskset.environment.metadata.portableTools)\n    || contentHash(javascript.tools.map(tool => tool.name)) !== contentHash(taskset.environment.toolNames)) throw new Error(\"Authored environment tools differ from the Taskset's declared tools.\");\n  const environment = createEnvironmentRelease({ schemaVersion: \"openpond.environmentRelease.v1\", id: `environment-${taskset.id}`, revision: taskset.revision,\n    contract: portableTasksetEnvironment(taskset), actionSchemaRef: repin(previous.environment.actionSchemaRef), observationSchemaRef: repin(previous.environment.observationSchemaRef), stateSchemaRef: repin(previous.environment.stateSchemaRef),\n    artifactCollection: previous.environment.artifactCollection, adapterConformanceHashes: {},\n    metadata: { javascriptEnvironment: learningRef(javascript), resources: taskset.environment.resources ?? [] },\n  });\n  const prepared = TasksetSchema.parse({ ...taskset, environment: { ...taskset.environment,\n    metadata: { ...taskset.environment.metadata, portableExecutionResources: { environment } },\n  } });\n  const releases = materializePortableTasksetRelease({ taskset: prepared, adapterId: adapterId });\n  const file = createTasksetPackageExecutionFile({ javascript, environment, verifierSet: releases.verifierSetRelease });\n  const nextInventory = [...inventory.filter(entry => entry.sourcePath !== declarationPath), { asset: file.asset, sourcePath: declarationPath }];\n  const finalized = TasksetSchema.parse({ ...prepared, metadata: { ...prepared.metadata, portableFileInventory: nextInventory } });\n  return { taskset: TasksetSchema.parse({ ...finalized, contentHash: computeTasksetHash(finalized) }), inventory: nextInventory,\n    generatedFiles: [{ path: declarationPath, role: \"environment\", content: new TextDecoder().decode(decodeTasksetPackageFile(file)) }],\n  };\n}\n", "import { contentHash } from \"@openpond/harness\";\nimport { ModelTasksetDraftPreparationSchema, type ModelTasksetDraftPreparation } from \"./model-taskset-authoring-contracts.js\";\nimport { publishModelTasksetDraftPackage } from \"./model-taskset-authoring.js\";\nimport { publishTasksetDraft } from \"./taskset-draft-publication.js\";\nimport { validateTasksetDraftWorkspace, decodeTasksetDraftWorkspaceFile, type TasksetDraftWorkspace } from \"./taskset-draft-workspace.js\";\nimport { renderTasksetDraftManifests } from \"./taskset-draft-manifests.js\";\nimport { AuthoredTasksetFileInventorySchema, isGeneratedTasksetPublicationFilePath, prepareAuthoredTasksetSource } from \"./taskset-authored-files.js\";\nimport { materializePortableTasksetRelease } from \"./taskset-authored-portable-release.js\";\nimport { createTasksetPackage, type TasksetPackage } from \"./taskset-package-contracts.js\";\n\n/** Use the same validation, file pinning and release projection as Desktop.\n * Compilation neither executes models/graders nor selects the resulting release.\n * The host supplies its retained preparation and later commits Model/draft CAS. */\nexport function compileTasksetDraftWorkspace(input: {\n  workspace: TasksetDraftWorkspace;\n  preparation: ModelTasksetDraftPreparation | null;\n  adapterId: string;\n  now: string;\n  source?: TasksetPackage;\n}) {\n  const workspace = validateTasksetDraftWorkspace(input.workspace);\n  const preparation = input.preparation === null ? null : ModelTasksetDraftPreparationSchema.parse(input.preparation);\n  if (preparation ? workspace.draft.id !== preparation.draftId || workspace.draft.modelScope?.modelId !== preparation.lineage.owner.modelId\n    || workspace.draft.profileId !== preparation.lineage.owner.scopeId\n    || contentHash(workspace.draft.modelScope?.source ?? null) !== contentHash(preparation)\n    : workspace.draft.modelScope?.source !== undefined) throw new Error(\"Taskset draft differs from its retained source preparation.\");\n  // Validation and publication may happen in different requests. Package\n  // identity depends on saved bytes, including their timestamp, not wall time.\n  const taskset = publishTasksetDraft({ draft: workspace.draft, now: workspace.draft.updatedAt, sourcePackageHash: workspace.contentHash });\n  const files = new Map(workspace.files.map(file => [file.path, decodeTasksetDraftWorkspaceFile(file)]));\n  for (const [path, source] of renderTasksetDraftManifests(workspace.draft)) if (!isGeneratedTasksetPublicationFilePath(path)) files.set(path, new TextEncoder().encode(source));\n  const authored = prepareAuthoredTasksetSource(taskset, files, input.adapterId);\n  for (const file of authored.generatedFiles) files.set(file.path, new TextEncoder().encode(file.content));\n  const releases = materializePortableTasksetRelease({ taskset: authored.taskset, adapterId: input.adapterId });\n  const inventory = AuthoredTasksetFileInventorySchema.parse(authored.taskset.metadata.portableFileInventory);\n  const edited = createTasksetPackage({ schemaVersion: \"openpond.tasksetPackage.v1\", taskset: releases.tasksetRelease,\n    environment: releases.environmentRelease, verifierSet: releases.verifierSetRelease,\n    files: inventory.map(entry => {\n      const bytes = files.get(entry.sourcePath);\n      if (!bytes) throw new Error(`Captured Taskset file is missing: ${entry.sourcePath}.`);\n      return { asset: entry.asset, base64: Buffer.from(bytes).toString(\"base64\") };\n    }),\n  });\n  return preparation ? publishModelTasksetDraftPackage({ preparation, edited, source: input.source }) : edited;\n}\n\n/** Model-derived authoring retains its stronger owner/source contract. */\nexport function compileModelTasksetDraftWorkspace(input: Parameters<typeof compileTasksetDraftWorkspace>[0]) {\n  if (!input.workspace.draft.modelScope) throw new Error(\"Taskset draft requires a Model owner.\");\n  return compileTasksetDraftWorkspace(input);\n}\n"],
+  "mappings": "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",
+  "names": ["learningRef", "sameLearningRef", "sealLearningContent", "TasksetReleaseSchema", "file", "lineage", "learningRef", "sameLearningRef", "TasksetReleaseSchema", "sealLearningContent", "learningRef", "sealLearningContent", "file", "sealLearningContent", "learningRef"]
+}

package/dist/{chunk-YGCHXNPI.js → chunk-DT7FRNIZ.js}

@@ -1,13 +1,7 @@
-import {
-  GraderSpecSchema
-} from "./chunk-TXQHWOFM.js";
-import {
-  decodeTasksetPackageFile
-} from "./chunk-42YOB36J.js";
 import {
   CapabilityRequirementSchema,
   ToolDeclarationSchema
-} from "./chunk-EAEYAU4R.js";
+} from "./chunk-Y4NGWGTA.js";
 import {
   ImmutableAssetRefSchema,
   contentHash,
@@ -373,97 +367,12 @@ function segment(value) {
   return normalized || "asset";
 }
 
-// src/taskset-package-grader-projection.ts
-import { compileBoundGraders as compileBoundGraders2, resolveBoundRewards } from "@openpond/evals/rewards";
-import { learningRef, verifyLearningTextAsset, RewardFixtureAuthoringFieldsSchema } from "@openpond/evals/learning";
-import { z } from "zod";
-function importedPackageGraders(value) {
-  const authoring = value.taskset.metadata.ordinaryAuthoring;
-  const calibrationFixtures = z.record(z.string(), z.array(z.string().min(1)).max(1e5)).parse(authoring?.judgeCalibrationFixtures ?? {});
-  return value.taskset.graders.map((grader) => {
-    const base = { ...grader, label: grader.id, metadata: { portableGrader: grader } };
-    if (grader.kind === "custom_verifier") return GraderSpecSchema.parse({
-      ...base,
-      module: learningVerifierModule(grader.verifierRef.contentHash),
-      exportName: grader.exportName ?? "verify",
-      metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef }
-    });
-    if (grader.kind === "human" || grader.kind === "model_judge") {
-      const file = value.files.find((file2) => file2.asset.id === grader.rubricRef.id);
-      if (!file) throw new Error(`Imported rubric is missing: ${grader.id}.`);
-      const rubric = new TextDecoder("utf-8", { fatal: true }).decode(decodeTasksetPackageFile(file));
-      const metadata = { ...base.metadata, portableRubricRef: grader.rubricRef };
-      if (grader.kind === "human") return GraderSpecSchema.parse({ ...base, rubric, metadata });
-      if (!grader.model) throw new Error(`Imported judge ${grader.id} requires its declared model before local preparation.`);
-      return GraderSpecSchema.parse({
-        ...base,
-        rubric,
-        metadata,
-        judge: grader.model,
-        temperature: grader.temperature ?? 0,
-        calibrationStatus: "pending",
-        calibrationFixtureRefs: calibrationFixtures[grader.id] ?? []
-      });
-    }
-    return GraderSpecSchema.parse({
-      ...base,
-      kind: grader.kind === "artifact" ? "file" : grader.kind,
-      config: grader.kind === "artifact" ? { ...grader.config, ...grader.config.refIncludes === void 0 ? {} : { pathIncludes: grader.config.refIncludes } } : grader.config
-    });
-  });
-}
-function projectLearningBatchGraders(binding, rewards, assets = []) {
-  const resolved = resolveBoundRewards(binding, rewards);
-  return compileBoundGraders2(binding, rewards).map((grader) => {
-    const reward = resolved.find(({ source }) => source.graderId === grader.id).reward;
-    const base = { ...grader, label: reward.name, metadata: { rewardBinding: learningRef(binding) } };
-    if (grader.kind === "model_judge") {
-      if (!grader.model || grader.calibrationStatus !== "passed" || !reward.calibrationCheckRef || !reward.fixtureSetRef) throw new Error(`Reward ${grader.id} needs a retained passing calibration check before preparation.`);
-      const rubric = assets.find((asset) => asset.id === grader.rubricRef.id);
-      const fixtures = assets.find((asset) => asset.id === reward.fixtureSetRef.id);
-      if (!rubric || !fixtures) throw new Error(`Reward ${grader.id} is missing its immutable rubric or calibration fixtures.`);
-      const fields = RewardFixtureAuthoringFieldsSchema.array().min(1).max(50).parse(JSON.parse(verifyLearningTextAsset(fixtures, reward.fixtureSetRef)));
-      return GraderSpecSchema.parse({
-        ...base,
-        rubric: verifyLearningTextAsset(rubric, grader.rubricRef),
-        judge: grader.model,
-        temperature: grader.temperature ?? 0,
-        calibrationFixtureRefs: fields.map((fixture) => fixture.id),
-        metadata: {
-          ...base.metadata,
-          portableRubricRef: grader.rubricRef,
-          calibrationEvidenceHash: reward.calibrationCheckRef.contentHash,
-          calibrationCheckRef: reward.calibrationCheckRef
-        }
-      });
-    }
-    if (grader.kind === "custom_verifier") return GraderSpecSchema.parse({
-      ...base,
-      module: learningVerifierModule(grader.verifierRef.contentHash),
-      exportName: grader.exportName ?? "verify",
-      metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef }
-    });
-    if (grader.kind === "human") {
-      const asset = assets.find((asset2) => asset2.id === grader.rubricRef.id);
-      if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable rubric.`);
-      return GraderSpecSchema.parse({ ...base, rubric: verifyLearningTextAsset(asset, grader.rubricRef) });
-    }
-    return GraderSpecSchema.parse({ ...base, kind: grader.kind === "artifact" ? "file" : grader.kind });
-  });
-}
-function learningVerifierModule(hash2) {
-  return `graders/reward-${hash2}.js`;
-}
-
 export {
   resolvePortableTasksetRewardExecution,
   materializePortableTasksetRelease,
   projectPreferenceComparisonRelease,
   portableTasksetEnvironment,
   portableTasksetTools,
-  projectPortableTaskRecord,
-  importedPackageGraders,
-  projectLearningBatchGraders,
-  learningVerifierModule
+  projectPortableTaskRecord
 };
-//# sourceMappingURL=chunk-YGCHXNPI.js.map
+//# sourceMappingURL=chunk-DT7FRNIZ.js.map