openpond-sdk 0.6.6 → 0.7.0

package/dist/{chunk-EJYSXE4V.js → chunk-32H2EJRA.js}

@@ -14,185 +14,27 @@ import {
   TasksetSourceRefSchema,
   computeTasksetHash,
   validateTaskset
-} from "./chunk-TXQHWOFM.js";
-import {
-  MAX_TASKSET_PACKAGE_BYTES,
-  TasksetPackageSchema,
-  tasksetPackageRewardBinding,
-  validateTasksetPackage
-} from "./chunk-42YOB36J.js";
+} from "./chunk-LGEF4S5I.js";
 import {
   ModelTasksetDraftPreparationSchema,
   TasksetDraftFileContentSchema,
   TasksetDraftFileMutationSchema,
   TasksetDraftFilePathSchema
 } from "./chunk-2U54EOXJ.js";
-import {
-  TasksetCatalogReleaseRefSchema
-} from "./chunk-A4ZDOZKP.js";
 import {
   canonicalJson,
   contentHash,
   sha256
 } from "./chunk-QUOW6URQ.js";
-import {
-  HostedModelProjectSummarySchema,
-  HostedModelProjectSyncSchema,
-  HostedModelProjectTrainingSetupSchema
-} from "./chunk-TCHAWJMB.js";
-
-// src/taskset-package-client.ts
-import { z } from "zod";
-import { learningRef } from "@openpond/evals/learning";
-var IdSchema = z.string().trim().min(1).max(500);
-var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
-var TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({
-  portableProjectId: true,
-  name: true,
-  objective: true,
-  defaultBaseModel: true,
-  defaultDestinationId: true,
-  sourceRevision: true,
-  sourceUpdatedAt: true
-}).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true }) }).strict();
-var TasksetPackagePublicationSchema = z.object({
-  schemaVersion: z.literal("openpond.tasksetPackagePublication.v1"),
-  operationId: IdSchema,
-  modelProjectId: IdSchema,
-  expectedProjectEtag: HashSchema.nullable(),
-  name: z.string().trim().min(1).max(200),
-  description: z.string().max(5e3),
-  buildIntent: z.enum(["demonstrations", "preferences", "verifiable_reward", "rubric", "discovery"]),
-  methodHint: z.enum(["sft", "dpo", "grpo", "ppo"]).nullable(),
-  package: TasksetPackageSchema,
-  modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),
-  evaluationPackage: TasksetPackageSchema.optional(),
-  selection: z.enum(["select", "attach"]).optional()
-}).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace Model configuration.").refine(
-  (value) => !value.evaluationPackage || value.modelConfiguration !== void 0 && value.modelConfiguration.trainingSetup.evaluationTasksetRef != null && contentHash(value.modelConfiguration.trainingSetup.evaluationTasksetRef) === contentHash(learningRef(value.evaluationPackage.taskset)),
-  "Evaluation package must match the selected immutable evaluation in Model configuration."
-);
-var TasksetPackageReceiptSchema = z.object({
-  schemaVersion: z.literal("openpond.tasksetPackageReceipt.v1"),
-  teamId: IdSchema,
-  modelProjectId: IdSchema,
-  operationId: IdSchema,
-  taskset: TasksetCatalogReleaseRefSchema,
-  packageHash: HashSchema,
-  hostedTasksetId: IdSchema,
-  projectEtag: HashSchema,
-  project: HostedModelProjectSummarySchema.optional(),
-  selection: z.enum(["select", "attach"]).optional(),
-  evaluation: z.object({ taskset: TasksetCatalogReleaseRefSchema, packageHash: HashSchema, hostedTasksetId: IdSchema }).strict().optional()
-}).strict();
-var TasksetPackageReadbackSchema = z.object({
-  schemaVersion: z.literal("openpond.tasksetPackageReadback.v1"),
-  teamId: IdSchema,
-  modelProjectId: IdSchema,
-  package: TasksetPackageSchema
-}).strict();
-var OpenPondTasksetPackageError = class extends Error {
-  constructor(status, code, message) {
-    super(message);
-    this.status = status;
-    this.code = code;
-    this.name = "OpenPondTasksetPackageError";
-  }
-  status;
-  code;
-};
-var OpenPondTasksetPackageClient = class {
-  #options;
-  constructor(options) {
-    const url = new URL(options.baseUrl);
-    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || !options.apiKey.trim() || !options.teamId.trim()) throw new Error("Taskset package client requires a clean HTTP(S) endpoint and workspace credentials.");
-    this.#options = { ...options, baseUrl: url.toString().replace(/\/+$/, "") };
-  }
-  async publish(input, options = {}) {
-    const request = TasksetPackagePublicationSchema.parse(input);
-    validateTasksetPackage(request.package);
-    if (request.evaluationPackage) validateTasksetPackage(request.evaluationPackage);
-    const receipt = TasksetPackageReceiptSchema.parse(await this.#request("", "POST", request, options.signal));
-    const release = request.package.taskset;
-    if (receipt.teamId !== this.#options.teamId || receipt.modelProjectId !== request.modelProjectId || receipt.operationId !== request.operationId || receipt.packageHash !== request.package.contentHash || receipt.taskset.id !== release.id || receipt.taskset.revision !== release.revision || receipt.taskset.contentHash !== release.contentHash) {
-      throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication receipt did not match the requested package and owner.");
-    }
-    if (request.selection !== void 0 && receipt.selection !== request.selection) throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain its selection mode.");
-    if (request.evaluationPackage && (!receipt.evaluation || receipt.evaluation.packageHash !== request.evaluationPackage.contentHash || contentHash(receipt.evaluation.taskset) !== contentHash(learningRef(request.evaluationPackage.taskset)))) {
-      throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain the complete selected evaluation package.");
-    }
-    if (request.selection === "attach" && receipt.projectEtag !== request.expectedProjectEtag) throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Attaching a historical Taskset changed the Model configuration.");
-    if (request.modelConfiguration) {
-      const expected = request.modelConfiguration;
-      const project = receipt.project;
-      const binding = tasksetPackageRewardBinding(request.package);
-      const setup = HostedModelProjectTrainingSetupSchema.parse({
-        ...expected.trainingSetup,
-        tasksetRef: learningRef(release),
-        rewardBindingRef: binding ? learningRef(binding) : null,
-        tasksetRelease: null
-      });
-      if (!project || project.teamId !== this.#options.teamId || project.etag !== receipt.projectEtag || ![project.id, project.portableProjectId].includes(request.modelProjectId) || project.portableProjectId !== expected.portableProjectId || project.name !== expected.name || project.objective !== expected.objective || project.sourceRevision !== expected.sourceRevision || Date.parse(project.sourceUpdatedAt) !== Date.parse(expected.sourceUpdatedAt) || contentHash(project.defaultBaseModel) !== contentHash(expected.defaultBaseModel) || project.defaultDestinationId !== expected.defaultDestinationId || contentHash(project.trainingSetup) !== contentHash(setup)) {
-        throw new OpenPondTasksetPackageError(502, "package_receipt_mismatch", "Taskset publication did not retain the requested Model configuration.");
-      }
-    }
-    return receipt;
-  }
-  async get(modelProjectId, reference, options = {}) {
-    const project = IdSchema.parse(modelProjectId);
-    const ref = TasksetCatalogReleaseRefSchema.parse(reference);
-    const expectedPackageHash = options.expectedPackageHash === void 0 ? void 0 : HashSchema.parse(options.expectedPackageHash);
-    const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, "GET", void 0, options.signal));
-    const taskset = response.package.taskset;
-    if (response.teamId !== this.#options.teamId || response.modelProjectId !== project || taskset.id !== ref.id || taskset.revision !== ref.revision || taskset.contentHash !== ref.contentHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the requested release and owner.");
-    if (expectedPackageHash !== void 0 && response.package.contentHash !== expectedPackageHash) throw new OpenPondTasksetPackageError(502, "package_readback_mismatch", "Taskset package did not match the saved publication receipt.");
-    return validateTasksetPackage(response.package);
-  }
-  async #request(path, method, body, signal) {
-    const serialized = body === void 0 ? void 0 : JSON.stringify(body);
-    if (serialized && new TextEncoder().encode(serialized).byteLength > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset publication exceeds the 64 MiB envelope.");
-    const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/taskset-packages${path}`, {
-      method,
-      headers: { Authorization: `Bearer ${this.#options.apiKey}`, "X-OpenPond-Team-Id": this.#options.teamId, Accept: "application/json", ...serialized ? { "Content-Type": "application/json" } : {} },
-      body: serialized,
-      signal,
-      redirect: "error"
-    });
-    const reader = response.body?.getReader();
-    if (!reader) throw new OpenPondTasksetPackageError(response.status, "empty_response", "Taskset package response was empty.");
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    let bytes = 0;
-    let text = "";
-    try {
-      while (true) {
-        const chunk = await reader.read();
-        if (chunk.done) break;
-        bytes += chunk.value.byteLength;
-        if (bytes > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, "package_too_large", "Taskset response exceeds the 64 MiB envelope.");
-        text += decoder.decode(chunk.value, { stream: true });
-      }
-      text += decoder.decode();
-    } finally {
-      await reader.cancel();
-      reader.releaseLock();
-    }
-    const payload = JSON.parse(text);
-    if (!response.ok) {
-      const error = z.object({ code: z.string(), message: z.string() }).safeParse(payload);
-      throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : "package_request_failed", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);
-    }
-    return payload;
-  }
-};
 
 // src/taskset-draft-document.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 import { TasksetMetricPolicySchema } from "@openpond/evals/metrics";
-var IdSchema2 = z2.string().trim().min(1).max(240);
-var TimestampSchema = z2.string().trim().min(1);
-var HashSchema2 = z2.string().trim().min(8).max(256);
-var CodeIdentifierSchema = z2.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
-var MetadataSchema = z2.record(z2.string(), z2.unknown()).default({});
+var IdSchema = z.string().trim().min(1).max(240);
+var TimestampSchema = z.string().trim().min(1);
+var HashSchema = z.string().trim().min(8).max(256);
+var CodeIdentifierSchema = z.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);
+var MetadataSchema = z.record(z.string(), z.unknown()).default({});
 function safeRelativeFilePath(value) {
   const normalized = value.trim().replaceAll("\\", "/");
   if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
@@ -203,35 +45,35 @@ function safeRelativeFilePath(value) {
   );
 }
 var TaskDataDraftSchema = TaskDataRecordSchema.extend({
-  sourceRefs: z2.array(IdSchema2).max(100).default([])
+  sourceRefs: z.array(IdSchema).max(100).default([])
 });
-var TasksetDraftStatusSchema = z2.enum([
+var TasksetDraftStatusSchema = z.enum([
   "draft",
   "validating",
   "needs_review",
   "published"
 ]);
-var TasksetDraftReviewPolicySchema = z2.object({
-  enabled: z2.boolean(),
-  candidateCount: z2.number().int().min(2).max(4),
-  minimumSamples: z2.number().int().min(1).max(1e4).default(100),
-  allowTies: z2.boolean(),
-  allowRejectAll: z2.boolean(),
-  rubric: z2.string().trim().max(5e4),
-  criteria: z2.array(z2.object({
-    id: IdSchema2,
-    label: z2.string().trim().min(1).max(500),
-    description: z2.string().trim().max(1e4),
-    weight: z2.number().nonnegative().max(1e3)
+var TasksetDraftReviewPolicySchema = z.object({
+  enabled: z.boolean(),
+  candidateCount: z.number().int().min(2).max(4),
+  minimumSamples: z.number().int().min(1).max(1e4).default(100),
+  allowTies: z.boolean(),
+  allowRejectAll: z.boolean(),
+  rubric: z.string().trim().max(5e4),
+  criteria: z.array(z.object({
+    id: IdSchema,
+    label: z.string().trim().min(1).max(500),
+    description: z.string().trim().max(1e4),
+    weight: z.number().nonnegative().max(1e3)
   })).max(100)
 });
-var TasksetDraftOutputContractSchema = z2.object({
-  mode: z2.enum(["text", "structured_json", "artifacts"]),
-  jsonSchema: z2.record(z2.string(), z2.unknown()).nullable(),
-  renderer: z2.object({
-    module: z2.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Renderer modules must use a safe relative path."),
+var TasksetDraftOutputContractSchema = z.object({
+  mode: z.enum(["text", "structured_json", "artifacts"]),
+  jsonSchema: z.record(z.string(), z.unknown()).nullable(),
+  renderer: z.object({
+    module: z.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Renderer modules must use a safe relative path."),
     exportName: CodeIdentifierSchema,
-    configRef: z2.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Renderer configuration must use a safe relative path.").nullable().default(null)
+    configRef: z.string().trim().min(1).max(1e3).refine(safeRelativeFilePath, "Renderer configuration must use a safe relative path.").nullable().default(null)
   }).nullable()
 }).superRefine((output, context) => {
   if (output.mode === "structured_json" && !output.jsonSchema) {
@@ -249,23 +91,23 @@ var TasksetDraftOutputContractSchema = z2.object({
     });
   }
 });
-var TasksetDraftSchema = z2.object({
-  schemaVersion: z2.literal("openpond.tasksetDraft.v1"),
-  id: IdSchema2,
-  revision: z2.number().int().positive(),
-  profileId: IdSchema2,
-  modelScope: z2.object({
-    modelId: IdSchema2,
-    expectedModelRevision: z2.number().int().positive(),
+var TasksetDraftSchema = z.object({
+  schemaVersion: z.literal("openpond.tasksetDraft.v1"),
+  id: IdSchema,
+  revision: z.number().int().positive(),
+  profileId: IdSchema,
+  modelScope: z.object({
+    modelId: IdSchema,
+    expectedModelRevision: z.number().int().positive(),
     source: ModelTasksetDraftPreparationSchema.optional()
   }).strict().nullable().default(null),
-  name: z2.string().trim().max(500),
-  objective: z2.string().trim().max(2e4),
+  name: z.string().trim().max(500),
+  objective: z.string().trim().max(2e4),
   purpose: TasksetPurposeSchema.default("general"),
   benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),
   preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),
   status: TasksetDraftStatusSchema,
-  sourceRefs: z2.array(TasksetSourceRefSchema).max(1e5).default([]),
+  sourceRefs: z.array(TasksetSourceRefSchema).max(1e5).default([]),
   datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
   policy: TaskPolicyBoundarySchema,
   environment: TasksetEnvironmentContractSchema,
@@ -277,14 +119,14 @@ var TasksetDraftSchema = z2.object({
   capabilities: TasksetCapabilityManifestSchema,
   metrics: TasksetMetricPolicySchema,
   review: TasksetDraftReviewPolicySchema,
-  tasks: z2.array(TaskDataDraftSchema).max(1e6).default([]),
-  graders: z2.array(GraderSpecSchema).max(1e3).default([]),
-  graderFixtures: z2.array(GraderFixtureSchema).max(1e5).default([]),
+  tasks: z.array(TaskDataDraftSchema).max(1e6).default([]),
+  graders: z.array(GraderSpecSchema).max(1e3).default([]),
+  graderFixtures: z.array(GraderFixtureSchema).max(1e5).default([]),
   learningSignals: LearningSignalInventorySchema,
-  publishedTasksetRef: z2.object({
-    id: IdSchema2,
-    revision: z2.number().int().positive(),
-    contentHash: HashSchema2
+  publishedTasksetRef: z.object({
+    id: IdSchema,
+    revision: z.number().int().positive(),
+    contentHash: HashSchema
   }).nullable(),
   createdAt: TimestampSchema,
   updatedAt: TimestampSchema,
@@ -320,6 +162,246 @@ var TasksetDraftSchema = z2.object({
   }
 });
 
+// src/taskset-draft-files.ts
+var MAX_TASKSET_DRAFT_EDIT_FILE_BYTES = 6e6;
+var MANAGED_FILES = /* @__PURE__ */ new Set(["taskset.json", "capabilities.json", "data/tasks.jsonl", "tasks/tasks.jsonl", "graders/graders.json", "fixtures/grader-fixtures.json", "metrics/policy.json", "assets/manifest.json", "environment/contract.json", "environment/taskset.ts", "rubrics/preference-review.md", "comparisons/policy.json"]);
+function isWritableTasksetDraftFilePath(value) {
+  const path = TasksetDraftFilePathSchema.parse(value);
+  return !MANAGED_FILES.has(path) && !path.startsWith("source-artifacts/");
+}
+function isManagedTasksetDraftFilePath(value) {
+  return MANAGED_FILES.has(TasksetDraftFilePathSchema.parse(value));
+}
+function createTasksetDraftFile(path, bytes) {
+  const writable = isWritableTasksetDraftFilePath(path);
+  if (bytes.byteLength > MAX_TASKSET_DRAFT_EDIT_FILE_BYTES) throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
+  let content;
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    content = /[\u0000-\u0008\u000e-\u001f]/.test(text) ? base64Content(bytes) : { encoding: "utf8", data: text };
+  } catch {
+    content = base64Content(bytes);
+  }
+  return { path, writable, content, sizeBytes: bytes.byteLength, contentHash: sha256(bytes) };
+}
+function decodeTasksetDraftFileContent(input) {
+  const content = TasksetDraftFileContentSchema.parse(input);
+  let bytes;
+  try {
+    if (content.encoding === "utf8") bytes = new TextEncoder().encode(content.data);
+    else {
+      const raw = atob(content.data);
+      if (btoa(raw) !== content.data) throw new Error("Noncanonical base64");
+      bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+    }
+  } catch {
+    throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
+  }
+  if (bytes.byteLength > MAX_TASKSET_DRAFT_EDIT_FILE_BYTES) throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
+  return bytes;
+}
+function base64Content(bytes) {
+  let raw = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192) raw += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  return { encoding: "base64", data: btoa(raw) };
+}
+
+// src/taskset-draft-manifests.ts
+function configuredTasksetDraftFiles(draft) {
+  const configured = [];
+  if (draft.output.renderer) {
+    configured.push({
+      relativePath: draft.output.renderer.module,
+      source: `export async function ${draft.output.renderer.exportName}(output: unknown) {
+  // Return artifact paths or bytes derived from the model's structured output.
+  return output;
+}
+`
+    });
+  }
+  for (const grader of draft.graders) {
+    if (grader.kind !== "custom_verifier") continue;
+    configured.push({
+      relativePath: grader.module,
+      source: `export async function ${grader.exportName}(input: { output: unknown; task: unknown }) {
+  return { passed: false, score: 0, feedback: "Implement this verifier." };
+}
+`
+    });
+  }
+  if (draft.metrics.customAggregator) {
+    configured.push({
+      relativePath: draft.metrics.customAggregator.module,
+      source: `export function ${draft.metrics.customAggregator.exportName}(scores: number[]) {
+  return scores.length ? scores.reduce((sum, score) => sum + score, 0) / scores.length : 0;
+}
+`
+    });
+  }
+  for (const file of configured) TasksetDraftFilePathSchema.parse(file.relativePath);
+  return configured;
+}
+function renderTasksetDraftManifests(input) {
+  const draft = TasksetDraftSchema.parse(input);
+  return /* @__PURE__ */ new Map([
+    ["taskset.json", canonicalJson(draft)],
+    ["tasks/tasks.jsonl", jsonLines(draft.tasks)],
+    ["graders/graders.json", canonicalJson(draft.graders)],
+    ["fixtures/grader-fixtures.json", canonicalJson(draft.graderFixtures)],
+    ["metrics/policy.json", canonicalJson(draft.metrics)],
+    ["assets/manifest.json", canonicalJson(draft.tasks.flatMap((task) => task.assets ?? []))],
+    ["environment/contract.json", canonicalJson(draft.environment)],
+    ["rubrics/preference-review.md", rubricMarkdown(draft)],
+    ["comparisons/policy.json", canonicalJson(draft.review)]
+  ]);
+}
+function rubricMarkdown(draft) {
+  const criteria = draft.review.criteria.length ? `
+
+## Criteria
+
+${draft.review.criteria.map(
+    (criterion) => `- **${criterion.label}** (${criterion.weight}): ${criterion.description}`
+  ).join("\n")}` : "";
+  return `# Preference review rubric
+
+${draft.review.rubric}${criteria}
+`;
+}
+function jsonLines(values) {
+  return values.length ? `${values.map((value) => JSON.stringify(value)).join("\n")}
+` : "";
+}
+
+// src/taskset-draft-workspace.ts
+import { z as z2 } from "zod";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+var MAX_TASKSET_DRAFT_WORKSPACE_BYTES = 64 * 1024 * 1024;
+var HashSchema2 = z2.string().regex(/^[a-f0-9]{64}$/);
+var TasksetDraftWorkspaceFileSchema = z2.object({
+  path: TasksetDraftFilePathSchema,
+  contentHash: HashSchema2,
+  sizeBytes: z2.number().int().nonnegative().max(MAX_TASKSET_DRAFT_WORKSPACE_BYTES),
+  base64: z2.string().max(MAX_TASKSET_DRAFT_WORKSPACE_BYTES)
+}).strict();
+var WorkspaceContentSchema = z2.object({
+  schemaVersion: z2.literal("openpond.tasksetDraftWorkspace.v1"),
+  draft: TasksetDraftSchema,
+  files: z2.array(TasksetDraftWorkspaceFileSchema).max(1e4)
+}).strict();
+var TasksetDraftWorkspaceSchema = WorkspaceContentSchema.extend({ contentHash: HashSchema2 }).strict();
+function createTasksetDraftWorkspace(input) {
+  assertBoundedTaskJson(input, MAX_TASKSET_DRAFT_WORKSPACE_BYTES);
+  const content = WorkspaceContentSchema.parse(input);
+  content.files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+  return validateTasksetDraftWorkspace({ ...content, contentHash: contentHash(content) });
+}
+function validateTasksetDraftWorkspace(input) {
+  assertBoundedTaskJson(input, MAX_TASKSET_DRAFT_WORKSPACE_BYTES);
+  const workspace = TasksetDraftWorkspaceSchema.parse(input);
+  const { contentHash: expectedHash, ...content } = workspace;
+  if (contentHash(content) !== expectedHash) throw new Error("Taskset draft workspace differs from its retained bytes.");
+  let previousPath = null;
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of workspace.files) {
+    if (isManagedTasksetDraftFilePath(file.path)) throw new Error("Managed Taskset files are represented by the draft document.");
+    if (previousPath !== null && previousPath >= file.path) throw new Error("Taskset draft file paths must be unique and sorted.");
+    const segments = file.path.split("/");
+    for (let end = 1; end < segments.length; end++) if (paths.has(segments.slice(0, end).join("/"))) throw new Error("A Taskset draft file occupies another file's directory.");
+    decodeTasksetDraftWorkspaceFile(file);
+    paths.add(file.path);
+    previousPath = file.path;
+  }
+  return workspace;
+}
+function readTasksetDraftWorkspaceFile(input, path) {
+  const workspace = validateTasksetDraftWorkspace(input);
+  TasksetDraftFilePathSchema.parse(path);
+  const file = workspace.files.find((candidate) => candidate.path === path);
+  const manifest = isManagedTasksetDraftFilePath(path) ? renderTasksetDraftManifests(workspace.draft).get(path) : void 0;
+  if (!file && manifest === void 0) throw new Error("Taskset draft file does not exist.");
+  const result = createTasksetDraftFile(path, file ? decodeTasksetDraftWorkspaceFile(file) : new TextEncoder().encode(manifest));
+  return { draftRevision: workspace.draft.revision, file: { ...result, writable: result.writable && workspace.draft.status !== "published" } };
+}
+function listTasksetDraftWorkspaceFiles(input) {
+  const workspace = validateTasksetDraftWorkspace(input);
+  const files = workspace.files.map((file) => ({
+    path: file.path,
+    sizeBytes: file.sizeBytes,
+    writable: workspace.draft.status !== "published" && isWritableTasksetDraftFilePath(file.path)
+  }));
+  for (const [path, content] of renderTasksetDraftManifests(workspace.draft)) files.push({ path, sizeBytes: new TextEncoder().encode(content).byteLength, writable: false });
+  return { draftRevision: workspace.draft.revision, files: files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0) };
+}
+function saveTasksetDraftWorkspaceDocument(input) {
+  const workspace = editableWorkspace(input.workspace, input.expectedDraftRevision);
+  const draft = TasksetDraftSchema.parse(input.draft);
+  const current = workspace.draft;
+  if (draft.id !== current.id || draft.profileId !== current.profileId || contentHash(draft.modelScope) !== contentHash(current.modelScope)) throw new Error("Taskset draft Model ownership cannot change.");
+  if (draft.revision !== current.revision || draft.status !== current.status || draft.createdAt !== current.createdAt || contentHash(draft.publishedTasksetRef) !== contentHash(current.publishedTasksetRef)) throw new Error("Taskset draft lifecycle fields cannot change through form edits.");
+  const files = [...workspace.files];
+  for (const configured of configuredTasksetDraftFiles(draft)) if (!files.some((file) => file.path === configured.relativePath)) {
+    const bytes = new TextEncoder().encode(configured.source);
+    files.push({ path: configured.relativePath, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: base64(bytes) });
+  }
+  const aggregator = draft.metrics.customAggregator;
+  const module = aggregator ? files.find((file) => file.path === aggregator.module) : void 0;
+  return createTasksetDraftWorkspace({
+    schemaVersion: workspace.schemaVersion,
+    files,
+    draft: {
+      ...draft,
+      revision: current.revision + 1,
+      status: "draft",
+      updatedAt: input.now,
+      ...aggregator && module ? { metrics: { ...draft.metrics, customAggregator: { ...aggregator, contentHash: module.contentHash } } } : {}
+    }
+  });
+}
+function saveTasksetDraftWorkspaceFile(input) {
+  const mutation = TasksetDraftFileMutationSchema.parse(input.mutation);
+  const workspace = editableWorkspace(input.workspace, mutation.expectedDraftRevision);
+  if (workspace.draft.id !== mutation.draftId) throw new Error("Taskset draft file belongs to another draft.");
+  if (!isWritableTasksetDraftFilePath(mutation.path)) throw new Error("This file is managed by the Taskset forms or retained source history.");
+  const previous = workspace.files.find((file) => file.path === mutation.path);
+  if ((previous?.contentHash ?? null) !== mutation.expectedFileHash) throw new Error("Taskset draft file changed. Reload it before saving.");
+  if (!previous && mutation.content === null) throw new Error("Taskset draft file does not exist.");
+  const files = workspace.files.filter((file) => file.path !== mutation.path);
+  if (mutation.content !== null) {
+    const bytes = decodeTasksetDraftFileContent(mutation.content);
+    files.push({ path: mutation.path, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: base64(bytes) });
+  }
+  return createTasksetDraftWorkspace({
+    schemaVersion: workspace.schemaVersion,
+    files,
+    draft: { ...workspace.draft, revision: workspace.draft.revision + 1, status: "draft", updatedAt: input.now }
+  });
+}
+function editableWorkspace(input, expectedRevision) {
+  const workspace = validateTasksetDraftWorkspace(input);
+  if (workspace.draft.status === "published") throw new Error("Published Taskset drafts are immutable.");
+  if (workspace.draft.revision !== expectedRevision) throw new Error("Taskset draft changed. Reload before saving.");
+  return workspace;
+}
+function decodeTasksetDraftWorkspaceFile(input) {
+  const file = TasksetDraftWorkspaceFileSchema.parse(input);
+  let raw;
+  try {
+    raw = atob(file.base64);
+  } catch {
+    throw new Error("Taskset draft file contains invalid base64.");
+  }
+  if (btoa(raw) !== file.base64) throw new Error("Taskset draft file contains noncanonical base64.");
+  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
+  if (bytes.byteLength !== file.sizeBytes || sha256(bytes) !== file.contentHash) throw new Error("Taskset draft file differs from its retained bytes.");
+  return bytes;
+}
+function base64(bytes) {
+  let raw = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192) raw += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  return btoa(raw);
+}
+
 // src/taskset-draft-authoring.ts
 var TasksetDraftPublishError = class extends Error {
   issues;
@@ -642,263 +724,12 @@ function tasksetOutputContract(metadata) {
   return { mode: "text", jsonSchema: null, renderer: null };
 }
 
-// src/taskset-draft-files.ts
-var MAX_TASKSET_DRAFT_EDIT_FILE_BYTES = 6e6;
-var MANAGED_FILES = /* @__PURE__ */ new Set(["taskset.json", "capabilities.json", "data/tasks.jsonl", "tasks/tasks.jsonl", "graders/graders.json", "fixtures/grader-fixtures.json", "metrics/policy.json", "assets/manifest.json", "environment/contract.json", "environment/taskset.ts", "rubrics/preference-review.md", "comparisons/policy.json"]);
-function isWritableTasksetDraftFilePath(value) {
-  const path = TasksetDraftFilePathSchema.parse(value);
-  return !MANAGED_FILES.has(path) && !path.startsWith("source-artifacts/");
-}
-function isManagedTasksetDraftFilePath(value) {
-  return MANAGED_FILES.has(TasksetDraftFilePathSchema.parse(value));
-}
-function createTasksetDraftFile(path, bytes) {
-  const writable = isWritableTasksetDraftFilePath(path);
-  if (bytes.byteLength > MAX_TASKSET_DRAFT_EDIT_FILE_BYTES) throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
-  let content;
-  try {
-    const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-    content = /[\u0000-\u0008\u000e-\u001f]/.test(text) ? base64Content(bytes) : { encoding: "utf8", data: text };
-  } catch {
-    content = base64Content(bytes);
-  }
-  return { path, writable, content, sizeBytes: bytes.byteLength, contentHash: sha256(bytes) };
-}
-function decodeTasksetDraftFileContent(input) {
-  const content = TasksetDraftFileContentSchema.parse(input);
-  let bytes;
-  try {
-    if (content.encoding === "utf8") bytes = new TextEncoder().encode(content.data);
-    else {
-      const raw = atob(content.data);
-      if (btoa(raw) !== content.data) throw new Error("Noncanonical base64");
-      bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
-    }
-  } catch {
-    throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
-  }
-  if (bytes.byteLength > MAX_TASKSET_DRAFT_EDIT_FILE_BYTES) throw new Error("Taskset draft file content is invalid or exceeds 6 MB.");
-  return bytes;
-}
-function base64Content(bytes) {
-  let raw = "";
-  for (let offset = 0; offset < bytes.length; offset += 8192) raw += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
-  return { encoding: "base64", data: btoa(raw) };
-}
-
-// src/taskset-draft-manifests.ts
-function configuredTasksetDraftFiles(draft) {
-  const configured = [];
-  if (draft.output.renderer) {
-    configured.push({
-      relativePath: draft.output.renderer.module,
-      source: `export async function ${draft.output.renderer.exportName}(output: unknown) {
-  // Return artifact paths or bytes derived from the model's structured output.
-  return output;
-}
-`
-    });
-  }
-  for (const grader of draft.graders) {
-    if (grader.kind !== "custom_verifier") continue;
-    configured.push({
-      relativePath: grader.module,
-      source: `export async function ${grader.exportName}(input: { output: unknown; task: unknown }) {
-  return { passed: false, score: 0, feedback: "Implement this verifier." };
-}
-`
-    });
-  }
-  if (draft.metrics.customAggregator) {
-    configured.push({
-      relativePath: draft.metrics.customAggregator.module,
-      source: `export function ${draft.metrics.customAggregator.exportName}(scores: number[]) {
-  return scores.length ? scores.reduce((sum, score) => sum + score, 0) / scores.length : 0;
-}
-`
-    });
-  }
-  for (const file of configured) TasksetDraftFilePathSchema.parse(file.relativePath);
-  return configured;
-}
-function renderTasksetDraftManifests(input) {
-  const draft = TasksetDraftSchema.parse(input);
-  return /* @__PURE__ */ new Map([
-    ["taskset.json", canonicalJson(draft)],
-    ["tasks/tasks.jsonl", jsonLines(draft.tasks)],
-    ["graders/graders.json", canonicalJson(draft.graders)],
-    ["fixtures/grader-fixtures.json", canonicalJson(draft.graderFixtures)],
-    ["metrics/policy.json", canonicalJson(draft.metrics)],
-    ["assets/manifest.json", canonicalJson(draft.tasks.flatMap((task) => task.assets ?? []))],
-    ["environment/contract.json", canonicalJson(draft.environment)],
-    ["rubrics/preference-review.md", rubricMarkdown(draft)],
-    ["comparisons/policy.json", canonicalJson(draft.review)]
-  ]);
-}
-function rubricMarkdown(draft) {
-  const criteria = draft.review.criteria.length ? `
-
-## Criteria
-
-${draft.review.criteria.map(
-    (criterion) => `- **${criterion.label}** (${criterion.weight}): ${criterion.description}`
-  ).join("\n")}` : "";
-  return `# Preference review rubric
-
-${draft.review.rubric}${criteria}
-`;
-}
-function jsonLines(values) {
-  return values.length ? `${values.map((value) => JSON.stringify(value)).join("\n")}
-` : "";
-}
-
-// src/taskset-draft-workspace.ts
-import { z as z3 } from "zod";
-import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
-var MAX_TASKSET_DRAFT_WORKSPACE_BYTES = 64 * 1024 * 1024;
-var HashSchema3 = z3.string().regex(/^[a-f0-9]{64}$/);
-var TasksetDraftWorkspaceFileSchema = z3.object({
-  path: TasksetDraftFilePathSchema,
-  contentHash: HashSchema3,
-  sizeBytes: z3.number().int().nonnegative().max(MAX_TASKSET_DRAFT_WORKSPACE_BYTES),
-  base64: z3.string().max(MAX_TASKSET_DRAFT_WORKSPACE_BYTES)
-}).strict();
-var WorkspaceContentSchema = z3.object({
-  schemaVersion: z3.literal("openpond.tasksetDraftWorkspace.v1"),
-  draft: TasksetDraftSchema,
-  files: z3.array(TasksetDraftWorkspaceFileSchema).max(1e4)
-}).strict();
-var TasksetDraftWorkspaceSchema = WorkspaceContentSchema.extend({ contentHash: HashSchema3 }).strict();
-function createTasksetDraftWorkspace(input) {
-  assertBoundedTaskJson(input, MAX_TASKSET_DRAFT_WORKSPACE_BYTES);
-  const content = WorkspaceContentSchema.parse(input);
-  content.files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
-  return validateTasksetDraftWorkspace({ ...content, contentHash: contentHash(content) });
-}
-function validateTasksetDraftWorkspace(input) {
-  assertBoundedTaskJson(input, MAX_TASKSET_DRAFT_WORKSPACE_BYTES);
-  const workspace = TasksetDraftWorkspaceSchema.parse(input);
-  const { contentHash: expectedHash, ...content } = workspace;
-  if (contentHash(content) !== expectedHash) throw new Error("Taskset draft workspace differs from its retained bytes.");
-  let previousPath = null;
-  const paths = /* @__PURE__ */ new Set();
-  for (const file of workspace.files) {
-    if (isManagedTasksetDraftFilePath(file.path)) throw new Error("Managed Taskset files are represented by the draft document.");
-    if (previousPath !== null && previousPath >= file.path) throw new Error("Taskset draft file paths must be unique and sorted.");
-    const segments = file.path.split("/");
-    for (let end = 1; end < segments.length; end++) if (paths.has(segments.slice(0, end).join("/"))) throw new Error("A Taskset draft file occupies another file's directory.");
-    decodeTasksetDraftWorkspaceFile(file);
-    paths.add(file.path);
-    previousPath = file.path;
-  }
-  return workspace;
-}
-function readTasksetDraftWorkspaceFile(input, path) {
-  const workspace = validateTasksetDraftWorkspace(input);
-  TasksetDraftFilePathSchema.parse(path);
-  const file = workspace.files.find((candidate) => candidate.path === path);
-  const manifest = isManagedTasksetDraftFilePath(path) ? renderTasksetDraftManifests(workspace.draft).get(path) : void 0;
-  if (!file && manifest === void 0) throw new Error("Taskset draft file does not exist.");
-  const result = createTasksetDraftFile(path, file ? decodeTasksetDraftWorkspaceFile(file) : new TextEncoder().encode(manifest));
-  return { draftRevision: workspace.draft.revision, file: { ...result, writable: result.writable && workspace.draft.status !== "published" } };
-}
-function listTasksetDraftWorkspaceFiles(input) {
-  const workspace = validateTasksetDraftWorkspace(input);
-  const files = workspace.files.map((file) => ({
-    path: file.path,
-    sizeBytes: file.sizeBytes,
-    writable: workspace.draft.status !== "published" && isWritableTasksetDraftFilePath(file.path)
-  }));
-  for (const [path, content] of renderTasksetDraftManifests(workspace.draft)) files.push({ path, sizeBytes: new TextEncoder().encode(content).byteLength, writable: false });
-  return { draftRevision: workspace.draft.revision, files: files.sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0) };
-}
-function saveTasksetDraftWorkspaceDocument(input) {
-  const workspace = editableWorkspace(input.workspace, input.expectedDraftRevision);
-  const draft = TasksetDraftSchema.parse(input.draft);
-  const current = workspace.draft;
-  if (draft.id !== current.id || draft.profileId !== current.profileId || contentHash(draft.modelScope) !== contentHash(current.modelScope)) throw new Error("Taskset draft Model ownership cannot change.");
-  if (draft.revision !== current.revision || draft.status !== current.status || draft.createdAt !== current.createdAt || contentHash(draft.publishedTasksetRef) !== contentHash(current.publishedTasksetRef)) throw new Error("Taskset draft lifecycle fields cannot change through form edits.");
-  const files = [...workspace.files];
-  for (const configured of configuredTasksetDraftFiles(draft)) if (!files.some((file) => file.path === configured.relativePath)) {
-    const bytes = new TextEncoder().encode(configured.source);
-    files.push({ path: configured.relativePath, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: base64(bytes) });
-  }
-  const aggregator = draft.metrics.customAggregator;
-  const module = aggregator ? files.find((file) => file.path === aggregator.module) : void 0;
-  return createTasksetDraftWorkspace({
-    schemaVersion: workspace.schemaVersion,
-    files,
-    draft: {
-      ...draft,
-      revision: current.revision + 1,
-      status: "draft",
-      updatedAt: input.now,
-      ...aggregator && module ? { metrics: { ...draft.metrics, customAggregator: { ...aggregator, contentHash: module.contentHash } } } : {}
-    }
-  });
-}
-function saveTasksetDraftWorkspaceFile(input) {
-  const mutation = TasksetDraftFileMutationSchema.parse(input.mutation);
-  const workspace = editableWorkspace(input.workspace, mutation.expectedDraftRevision);
-  if (workspace.draft.id !== mutation.draftId) throw new Error("Taskset draft file belongs to another draft.");
-  if (!isWritableTasksetDraftFilePath(mutation.path)) throw new Error("This file is managed by the Taskset forms or retained source history.");
-  const previous = workspace.files.find((file) => file.path === mutation.path);
-  if ((previous?.contentHash ?? null) !== mutation.expectedFileHash) throw new Error("Taskset draft file changed. Reload it before saving.");
-  if (!previous && mutation.content === null) throw new Error("Taskset draft file does not exist.");
-  const files = workspace.files.filter((file) => file.path !== mutation.path);
-  if (mutation.content !== null) {
-    const bytes = decodeTasksetDraftFileContent(mutation.content);
-    files.push({ path: mutation.path, contentHash: sha256(bytes), sizeBytes: bytes.byteLength, base64: base64(bytes) });
-  }
-  return createTasksetDraftWorkspace({
-    schemaVersion: workspace.schemaVersion,
-    files,
-    draft: { ...workspace.draft, revision: workspace.draft.revision + 1, status: "draft", updatedAt: input.now }
-  });
-}
-function editableWorkspace(input, expectedRevision) {
-  const workspace = validateTasksetDraftWorkspace(input);
-  if (workspace.draft.status === "published") throw new Error("Published Taskset drafts are immutable.");
-  if (workspace.draft.revision !== expectedRevision) throw new Error("Taskset draft changed. Reload before saving.");
-  return workspace;
-}
-function decodeTasksetDraftWorkspaceFile(input) {
-  const file = TasksetDraftWorkspaceFileSchema.parse(input);
-  let raw;
-  try {
-    raw = atob(file.base64);
-  } catch {
-    throw new Error("Taskset draft file contains invalid base64.");
-  }
-  if (btoa(raw) !== file.base64) throw new Error("Taskset draft file contains noncanonical base64.");
-  const bytes = Uint8Array.from(raw, (character) => character.charCodeAt(0));
-  if (bytes.byteLength !== file.sizeBytes || sha256(bytes) !== file.contentHash) throw new Error("Taskset draft file differs from its retained bytes.");
-  return bytes;
-}
-function base64(bytes) {
-  let raw = "";
-  for (let offset = 0; offset < bytes.length; offset += 8192) raw += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
-  return btoa(raw);
-}
-
 export {
-  TasksetPackageModelConfigurationSchema,
-  TasksetPackagePublicationSchema,
-  TasksetPackageReceiptSchema,
-  TasksetPackageReadbackSchema,
-  OpenPondTasksetPackageError,
-  OpenPondTasksetPackageClient,
   TaskDataDraftSchema,
   TasksetDraftStatusSchema,
   TasksetDraftReviewPolicySchema,
   TasksetDraftOutputContractSchema,
   TasksetDraftSchema,
-  TasksetDraftPublishError,
-  createTasksetDraft,
-  draftPublishIssues,
-  tasksetDraftFromTaskset,
-  publishTasksetDraft,
   MAX_TASKSET_DRAFT_EDIT_FILE_BYTES,
   isWritableTasksetDraftFilePath,
   isManagedTasksetDraftFilePath,
@@ -915,6 +746,11 @@ export {
   listTasksetDraftWorkspaceFiles,
   saveTasksetDraftWorkspaceDocument,
   saveTasksetDraftWorkspaceFile,
-  decodeTasksetDraftWorkspaceFile
+  decodeTasksetDraftWorkspaceFile,
+  TasksetDraftPublishError,
+  createTasksetDraft,
+  draftPublishIssues,
+  tasksetDraftFromTaskset,
+  publishTasksetDraft
 };
-//# sourceMappingURL=chunk-EJYSXE4V.js.map
+//# sourceMappingURL=chunk-32H2EJRA.js.map