openpond-sdk 0.5.5 → 0.5.7

package/dist/chunk-UJZ3XEE3.js

@@ -0,0 +1,902 @@
+import {
+  DatasetArtifactManifestSchema,
+  GraderFixtureSchema,
+  GraderSpecSchema,
+  LearningSignalInventorySchema,
+  MAX_TASKSET_PACKAGE_BYTES,
+  TaskDataRecordSchema,
+  TaskPolicyBoundarySchema,
+  TasksetBenchmarkBindingSchema,
+  TasksetCapabilityManifestSchema,
+  TasksetEnvironmentContractSchema,
+  TasksetPackageSchema,
+  TasksetPreferenceComparisonBindingSchema,
+  TasksetPurposeSchema,
+  TasksetSchema,
+  TasksetSourceRefSchema,
+  computeTasksetHash,
+  tasksetPackageRewardBinding,
+  validateTaskset,
+  validateTasksetPackage
+} from "./chunk-QFT2MCIC.js";
+import {
+  ModelTasksetDraftPreparationSchema,
+  TasksetDraftFileContentSchema,
+  TasksetDraftFileMutationSchema,
+  TasksetDraftFilePathSchema
+} from "./chunk-S7I45WJQ.js";
+import {
+  TasksetCatalogReleaseRefSchema
+} from "./chunk-A4ZDOZKP.js";
+import {
+  canonicalJson,
+  contentHash,
+  sha256
+} from "./chunk-QUOW6URQ.js";
+import {
+  HostedModelProjectSummarySchema,
+  HostedModelProjectSyncSchema,
+  HostedModelProjectTrainingSetupSchema
+} from "./chunk-ZNFOVV7B.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, recipe: 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(),
+  selection: z.enum(["select", "attach"]).optional()
+}).strict().refine((value) => value.selection !== "attach" || value.modelConfiguration === void 0, "Attachment-only publication cannot replace 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()
+}).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);
+    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.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,
+        recipe: 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 { 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({});
+function safeRelativeFilePath(value) {
+  const normalized = value.trim().replaceAll("\\", "/");
+  if (!normalized || normalized.startsWith("/") || normalized === "." || normalized === "..") {
+    return false;
+  }
+  return !normalized.split("/").some(
+    (segment) => !segment || segment === "." || segment === ".."
+  );
+}
+var TaskDataDraftSchema = TaskDataRecordSchema.extend({
+  sourceRefs: z2.array(IdSchema2).max(100).default([])
+});
+var TasksetDraftStatusSchema = z2.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)
+  })).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."),
+    exportName: CodeIdentifierSchema,
+    configRef: z2.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) {
+    context.addIssue({
+      code: "custom",
+      message: "Structured JSON output requires a JSON Schema.",
+      path: ["jsonSchema"]
+    });
+  }
+  if (output.mode === "text" && output.renderer) {
+    context.addIssue({
+      code: "custom",
+      message: "Text output cannot configure an artifact renderer.",
+      path: ["renderer"]
+    });
+  }
+});
+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(),
+    source: ModelTasksetDraftPreparationSchema.optional()
+  }).strict().nullable().default(null),
+  name: z2.string().trim().max(500),
+  objective: z2.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([]),
+  datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),
+  policy: TaskPolicyBoundarySchema,
+  environment: TasksetEnvironmentContractSchema,
+  output: TasksetDraftOutputContractSchema.default({
+    mode: "text",
+    jsonSchema: null,
+    renderer: null
+  }),
+  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([]),
+  learningSignals: LearningSignalInventorySchema,
+  publishedTasksetRef: z2.object({
+    id: IdSchema2,
+    revision: z2.number().int().positive(),
+    contentHash: HashSchema2
+  }).nullable(),
+  createdAt: TimestampSchema,
+  updatedAt: TimestampSchema,
+  metadata: MetadataSchema
+}).superRefine((draft, context) => {
+  if (draft.purpose === "benchmark" && !draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Benchmark drafts require an immutable benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.purpose !== "benchmark" && draft.benchmark) {
+    context.addIssue({
+      code: "custom",
+      message: "Only benchmark drafts may carry a benchmark binding.",
+      path: ["benchmark"]
+    });
+  }
+  if (draft.datasetArtifact && draft.tasks.length > 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Artifact-backed drafts may not duplicate canonical rows inline.",
+      path: ["tasks"]
+    });
+  }
+  if (draft.status === "published" && !draft.publishedTasksetRef) {
+    context.addIssue({
+      code: "custom",
+      message: "Published drafts require an immutable Taskset reference.",
+      path: ["publishedTasksetRef"]
+    });
+  }
+});
+
+// src/taskset-draft-authoring.ts
+var TasksetDraftPublishError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(issues.map((issue) => issue.message).join("\n"));
+    this.name = "TasksetDraftPublishError";
+    this.issues = issues;
+  }
+};
+function createTasksetDraft(input) {
+  const timestamp = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const id = input.id?.trim() || `taskset-draft-${globalThis.crypto.randomUUID()}`;
+  return TasksetDraftSchema.parse({
+    schemaVersion: "openpond.tasksetDraft.v1",
+    id,
+    revision: 1,
+    profileId: input.profileId,
+    modelScope: input.modelScope ?? null,
+    name: input.name?.trim() ?? "",
+    objective: "",
+    purpose: "general",
+    benchmark: null,
+    preferenceComparison: null,
+    status: "draft",
+    sourceRefs: [],
+    datasetArtifact: null,
+    policy: {
+      policyVisibleFields: ["input"],
+      privilegedFields: ["expectedOutput"],
+      hiddenGraderRefs: [],
+      connectedAppScopes: []
+    },
+    environment: {
+      protocolVersion: "openpond.taskEnvironment.v1",
+      kind: "chat",
+      entrypoint: "openpond-chat-v1",
+      stateful: false,
+      deterministicSeeds: true,
+      toolNames: [],
+      lifecycle: ["create", "reset", "step", "grade", "cleanup"],
+      defaultTimeoutMs: 12e4,
+      networkPolicy: "none",
+      resources: [],
+      metadata: {}
+    },
+    output: {
+      mode: "text",
+      jsonSchema: null,
+      renderer: null
+    },
+    capabilities: {
+      schemaVersion: "openpond.tasksetCapabilities.v1",
+      taskKind: "chat",
+      supportedSignals: [
+        "demonstration",
+        "preference",
+        "correction",
+        "feedback",
+        "reward",
+        "label"
+      ],
+      compatibleMethods: ["none"],
+      rewardKinds: ["none"],
+      requiresTools: false,
+      requiresState: false,
+      requiresPrivilegedGrading: true,
+      environmentPlacements: ["local", "remote", "colocated"],
+      exportable: true,
+      portabilityBlockers: []
+    },
+    metrics: {
+      schemaVersion: "openpond.tasksetMetricPolicy.v1",
+      primaryMetric: "score",
+      aggregation: "mean_score",
+      missingReward: "zero",
+      customAggregator: null
+    },
+    review: {
+      enabled: false,
+      candidateCount: 2,
+      minimumSamples: 100,
+      allowTies: true,
+      allowRejectAll: true,
+      rubric: "",
+      criteria: []
+    },
+    tasks: [],
+    graders: [],
+    graderFixtures: [],
+    learningSignals: {
+      demonstrations: [],
+      preferences: [],
+      corrections: [],
+      feedback: [],
+      rewards: [],
+      labels: []
+    },
+    publishedTasksetRef: null,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    metadata: {}
+  });
+}
+function draftPublishIssues(draft) {
+  const issues = [];
+  if (!draft.name.trim()) issues.push({ code: "name_missing", message: "Name is required.", path: "name" });
+  if (!draft.objective.trim()) issues.push({ code: "objective_missing", message: "Objective is required.", path: "objective" });
+  if (!draft.datasetArtifact && draft.tasks.length === 0) issues.push({ code: "tasks_missing", message: "Add at least one task or Dataset artifact.", path: "tasks" });
+  if (draft.graders.length === 0) issues.push({ code: "graders_missing", message: "Add at least one grader.", path: "graders" });
+  if (draft.graderFixtures.length === 0) issues.push({ code: "grader_fixtures_missing", message: "Add grader fixtures before publishing.", path: "graderFixtures" });
+  const sourceIds = new Set(draft.sourceRefs.map((source) => source.id));
+  for (const task of draft.tasks) {
+    for (const sourceId of task.sourceRefs) {
+      if (!sourceIds.has(sourceId)) issues.push({ code: "task_source_missing", message: `Task ${task.id} references missing source ${sourceId}.`, path: `tasks.${task.id}.sourceRefs` });
+    }
+  }
+  return issues;
+}
+
+// src/taskset-draft-publication.ts
+function tasksetDraftFromTaskset(tasksetInput, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const taskset = TasksetSchema.parse(tasksetInput);
+  return TasksetDraftSchema.parse({
+    schemaVersion: "openpond.tasksetDraft.v1",
+    id: `${taskset.id}-draft`,
+    revision: 1,
+    profileId: taskset.profileId,
+    name: taskset.name,
+    objective: taskset.objective,
+    purpose: taskset.purpose,
+    benchmark: taskset.benchmark,
+    preferenceComparison: taskset.preferenceComparison,
+    status: "draft",
+    sourceRefs: taskset.sourceRefs,
+    datasetArtifact: taskset.datasetArtifact ?? null,
+    policy: taskset.policy,
+    environment: taskset.environment,
+    output: tasksetOutputContract(taskset.metadata),
+    capabilities: taskset.capabilities,
+    metrics: taskset.metrics ?? {
+      schemaVersion: "openpond.tasksetMetricPolicy.v1",
+      primaryMetric: "score",
+      aggregation: "mean_score",
+      missingReward: "zero",
+      customAggregator: null
+    },
+    review: {
+      enabled: Boolean(taskset.preferenceComparison),
+      candidateCount: 2,
+      minimumSamples: 100,
+      allowTies: true,
+      allowRejectAll: true,
+      rubric: "",
+      criteria: []
+    },
+    tasks: taskset.tasks,
+    graders: taskset.graders,
+    graderFixtures: taskset.graderFixtures,
+    learningSignals: taskset.learningSignals,
+    publishedTasksetRef: {
+      id: taskset.id,
+      revision: taskset.revision,
+      contentHash: taskset.contentHash
+    },
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      ...taskset.metadata,
+      importedFromTaskset: {
+        id: taskset.id,
+        revision: taskset.revision,
+        contentHash: taskset.contentHash
+      }
+    }
+  });
+}
+function publishTasksetDraft(input) {
+  const draft = TasksetDraftSchema.parse(input.draft);
+  const timestamp = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const issues = draftPublishIssues(draft);
+  if (issues.length) throw new TasksetDraftPublishError(issues);
+  const preparedSource = draft.modelScope?.source;
+  if (preparedSource && input.tasksetId && input.tasksetId !== preparedSource.tasksetId) throw new Error("Taskset draft publication differs from its prepared identity.");
+  const tasksetId = preparedSource?.tasksetId || input.tasksetId?.trim() || draft.publishedTasksetRef?.id || draft.id.replace(/-draft$/, "");
+  const revision = preparedSource?.tasksetRevision ?? (draft.publishedTasksetRef?.id === tasksetId ? draft.publishedTasksetRef.revision + 1 : 1);
+  const sourceRefs = draft.sourceRefs.length ? draft.sourceRefs : [generatedDraftSource(draft, tasksetId, timestamp)];
+  const defaultSourceId = sourceRefs[0].id;
+  const tasks = draft.tasks.map((task) => TaskDataRecordSchema.parse({
+    ...task,
+    sourceRefs: task.sourceRefs.length ? task.sourceRefs : [defaultSourceId],
+    metadata: {
+      exampleOrigin: "expert_authored",
+      ...task.metadata
+    }
+  }));
+  const authoredMethod = draft.capabilities.compatibleMethods.find(
+    (method) => method !== "none" && method !== "retrieval"
+  ) ?? null;
+  const buildIntent = buildIntentForDraft(draft);
+  const taskset = TasksetSchema.parse({
+    schemaVersion: "openpond.taskset.v1",
+    id: tasksetId,
+    revision,
+    profileId: draft.profileId,
+    profileRelease: null,
+    createImproveRunId: null,
+    name: draft.name,
+    objective: draft.objective,
+    purpose: draft.purpose,
+    benchmark: draft.benchmark,
+    preferenceComparison: draft.preferenceComparison,
+    status: "needs_review",
+    sourceRefs,
+    datasetArtifact: draft.datasetArtifact ?? null,
+    policy: draft.policy,
+    environment: draft.environment,
+    capabilities: draft.capabilities,
+    metrics: draft.metrics,
+    tasks,
+    graders: draft.graders,
+    graderFixtures: draft.graderFixtures,
+    learningSignals: draft.learningSignals,
+    authoringProvenance: {
+      schemaVersion: "openpond.taskAuthoringProvenance.v1",
+      model: null,
+      modelConfig: {},
+      skillHash: contentHash("openpond-taskset-draft-authoring-v1"),
+      promptTemplateVersion: "taskset-draft-v1",
+      buildIntent,
+      buildSpecification: null,
+      evidenceHashes: sourceRefs.map((source) => source.sourceHash),
+      tasksetSdkVersion: "draft-v1",
+      sourceCommit: null,
+      repairHistory: [],
+      createdAt: timestamp
+    },
+    readiness: null,
+    contentHash: "00000000",
+    createdAt: revision === 1 ? draft.createdAt : timestamp,
+    updatedAt: timestamp,
+    metadata: {
+      ...draft.metadata,
+      ...preparedSource ? { modelTasksetAuthoring: preparedSource.lineage } : {},
+      tasksetReviewPolicy: draft.review,
+      tasksetOutputContract: draft.output,
+      ...input.sourcePackageHash ? { sourcePackageHash: input.sourcePackageHash } : {},
+      ...authoredMethod ? { trainingMethod: authoredMethod } : {},
+      diagnosis: {
+        schemaVersion: "openpond.capabilityDiagnosis.v1",
+        summary: draft.objective,
+        stableBehavior: [draft.objective],
+        changingKnowledge: [],
+        requiredContext: [],
+        requiredTools: draft.environment.toolNames,
+        intervention: authoredMethod === "dpo" ? "preference" : authoredMethod === "grpo" || authoredMethod === "ppo" ? "grpo_rft" : authoredMethod === "sft" ? "sft" : "no_training",
+        trainingEligible: authoredMethod !== null,
+        rationale: authoredMethod ? [`The author selected ${authoredMethod.toUpperCase()} compatibility.`] : ["The Taskset is currently configured for evaluation only."],
+        confidence: 1
+      }
+    }
+  });
+  const hashed = TasksetSchema.parse({
+    ...taskset,
+    contentHash: computeTasksetHash(taskset)
+  });
+  const report = validateTaskset(hashed);
+  const validationErrors = report.issues.filter((issue) => issue.severity === "error");
+  if (validationErrors.length) {
+    throw new TasksetDraftPublishError(validationErrors.map((issue) => ({
+      code: issue.code,
+      message: issue.message,
+      path: issue.path
+    })));
+  }
+  return hashed;
+}
+function generatedDraftSource(draft, tasksetId, timestamp) {
+  const generatorHash = contentHash({
+    draftId: draft.id,
+    draftRevision: draft.revision,
+    tasks: draft.tasks
+  });
+  return {
+    schemaVersion: "openpond.generatedDatasetSource.v1",
+    kind: "generated",
+    id: `source-${tasksetId}`,
+    profileId: draft.profileId,
+    title: `${draft.name} manual authoring`,
+    sourceHash: generatorHash,
+    occurredAt: timestamp,
+    licensingStatus: "approved",
+    secretScanStatus: "passed",
+    piiScanStatus: "passed",
+    generatorId: "openpond-taskset-draft",
+    generatorVersion: "1",
+    seed: 0,
+    generatorHash,
+    metadata: { draftId: draft.id, draftRevision: draft.revision }
+  };
+}
+function buildIntentForDraft(draft) {
+  if (draft.learningSignals.preferences.length) return "preferences";
+  if (draft.learningSignals.rewards.length) return "verifiable_reward";
+  if (draft.learningSignals.labels.length) return "rubric";
+  return "demonstrations";
+}
+function tasksetOutputContract(metadata) {
+  const value = metadata.tasksetOutputContract;
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  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,
+  createTasksetDraftFile,
+  decodeTasksetDraftFileContent,
+  configuredTasksetDraftFiles,
+  renderTasksetDraftManifests,
+  MAX_TASKSET_DRAFT_WORKSPACE_BYTES,
+  TasksetDraftWorkspaceFileSchema,
+  TasksetDraftWorkspaceSchema,
+  createTasksetDraftWorkspace,
+  validateTasksetDraftWorkspace,
+  readTasksetDraftWorkspaceFile,
+  listTasksetDraftWorkspaceFiles,
+  saveTasksetDraftWorkspaceDocument,
+  saveTasksetDraftWorkspaceFile,
+  decodeTasksetDraftWorkspaceFile
+};
+//# sourceMappingURL=chunk-UJZ3XEE3.js.map