npm - openpond-sdk - Versions diffs - 0.12.4 → 0.12.6 - Mend

openpond-sdk 0.12.4 → 0.12.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (160) hide show

package/dist/types/packages/sdk/src/training.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"training.d.ts","sourceRoot":"","sources":["../../../../../src/training.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA6D+B,2BAA2B;;;;;;;;;;;;0BAY3B,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;uBAatC;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAeiB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;qBAQH,MAAM,mBAAmB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;0BAY1B,MAAM,mBAAmB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYvC,MAAM;;;;;;;;;;;mBAUL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAMlB,MAAM,cACD;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,YACtC;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAyB5B,MAAM;;;;;;;;EAY3B"}
1	+ {"version":3,"file":"training.d.ts","sourceRoot":"","sources":["../../../../../src/training.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAiE+B,2BAA2B;;;;;;;;;;;;0BAY3B,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAatC;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAeiB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAQH,MAAM,mBAAmB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAY1B,MAAM,mBAAmB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAY5B,MAAM,SAAS,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYjF,MAAM;;;;;;;;;;;mBAUL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAMlB,MAAM,cACD;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,YACtC;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAyB5B,MAAM;;;;;;;;EAY3B"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "openpond-sdk",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "description": "Server-side TypeScript SDK for OpenPond sandboxes and agentic work",
   "license": "MIT",
   "type": "module",
@@ -188,8 +188,8 @@
     "vitest": "4.1.10"
   },
   "dependencies": {
-    "@openpond/evals": "^0.12.1",
-    "@openpond/harness": "^0.4.9",
+    "@openpond/evals": "^0.12.2",
+    "@openpond/harness": "^0.4.10",
     "yaml": "^2.9.0",
     "esbuild": "0.28.1",
     "zod": "^4.1.13"

package/dist/chunk-B5XTGEBE.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"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 { resolveStructuredOutput, 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, maximumBytes = MAX_TASKSET_PACKAGE_BYTES) {\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 > maximumBytes * 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 outputSchemaRefs: Record<string, ImmutableAssetRef> = {};\n for (const output of task.requiredOutputs ?? []) if (output.submissionMode === \"structured_json\") {\n if (!output.schemaRef || output.mediaType !== \"application/json\") throw new Error(\"Structured outputs require a JSON schemaRef and application/json.\");\n const prior = (task.metadata.portableTaskRecord as { requiredOutputs?: { path: string; schemaRef?: ImmutableAssetRef | null }[] } | undefined)?.requiredOutputs?.find(item => item.path === output.path)?.schemaRef;\n const sourcePath = prior?.id === output.schemaRef ? prior.path : output.schemaRef;\n const schema = ref(output.schemaRef, sourcePath, \"application/schema+json\", \"policy\");\n if (prior && prior.id === output.schemaRef && prior.visibility !== \"policy\") throw new Error(\"Structured output schema must be policy-visible.\");\n resolveStructuredOutput(bytes.get(sourcePath)!, schema.contentHash);\n outputSchemaRefs[output.schemaRef] = schema;\n }\n if (Object.keys(outputSchemaRefs).length) task.metadata = { ...task.metadata, outputSchemaRefs };\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 let asset = ref(`rubric-${grader.id}`, sourcePath, \"text/markdown\", \"verifier\");\n const previous = ImmutableAssetRefSchema.safeParse(grader.metadata.portableRubricRef);\n if (previous.success && previous.data.contentHash === asset.contentHash && previous.data.sizeBytes === asset.sizeBytes) {\n if (previous.data.visibility === \"policy\") throw new Error(\"A grader rubric cannot become policy-visible.\");\n asset = previous.data;\n }\n add(asset, sourcePath);\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/contracts\";\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 maximumBytes?: number;\n sourceWorkspaceHash?: string;\n}) {\n const workspace = validateTasksetDraftWorkspace(input.workspace, input.maximumBytes);\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: input.sourceWorkspaceHash ?? 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, input.maximumBytes);\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 }, input.maximumBytes);\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-BVMR5OFW.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"sources":["../src/taskset-package-client.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { TasksetCatalogReleaseRefSchema } from \"./taskset-catalog.js\";\nimport { MAX_TASKSET_PACKAGE_BYTES, TasksetPackageSchema, tasksetPackageRewardBinding, validateTasksetPackage, type TasksetPackage } from \"./taskset-package-contracts.js\";\nimport { HostedModelProjectSummarySchema, HostedModelProjectSyncSchema, HostedModelProjectTrainingSetupSchema } from \"./model-projects.js\";\nimport { contentHash } from \"@openpond/harness\";\nimport { learningRef } from \"@openpond/evals/learning\";\n\nconst IdSchema = z.string().trim().min(1).max(500);\nconst HashSchema = z.string().regex(/^[a-f0-9]{64}$/);\n/** Configuration and package selection share one hosted commit. Package-owned\n * references cannot accidentally contain a Desktop-local content hash. */\nexport const TasksetPackageModelConfigurationSchema = HostedModelProjectSyncSchema.pick({\n portableProjectId: true, name: true, objective: true, defaultBaseModel: true, defaultDestinationId: true,\n sourceRevision: true, sourceUpdatedAt: true,\n}).extend({ trainingSetup: HostedModelProjectTrainingSetupSchema.omit({ tasksetRef: true, rewardBindingRef: true, tasksetRelease: true }) }).strict();\nexport const TasksetPackagePublicationSchema = z.object({\n schemaVersion: z.literal(\"openpond.tasksetPackagePublication.v1\"),\n operationId: IdSchema, modelProjectId: IdSchema, expectedProjectEtag: HashSchema.nullable(),\n name: z.string().trim().min(1).max(200), description: z.string().max(5_000),\n buildIntent: z.enum([\"demonstrations\", \"preferences\", \"verifiable_reward\", \"rubric\", \"discovery\"]),\n methodHint: z.enum([\"sft\", \"dpo\", \"grpo\", \"ppo\"]).nullable(), package: TasksetPackageSchema,\n modelConfiguration: TasksetPackageModelConfigurationSchema.optional(),\n evaluationPackage: TasksetPackageSchema.optional(),\n selection: z.enum([\"select\", \"attach\"]).optional(),\n}).strict().refine(value => value.selection !== \"attach\" || value.modelConfiguration === undefined, \"Attachment-only publication cannot replace Model configuration.\")\n .refine(value => !value.evaluationPackage || (value.modelConfiguration !== undefined\n && value.modelConfiguration.trainingSetup.evaluationTasksetRef != null\n && contentHash(value.modelConfiguration.trainingSetup.evaluationTasksetRef) === contentHash(learningRef(value.evaluationPackage.taskset))),\n \"Evaluation package must match the selected immutable evaluation in Model configuration.\");\nexport const TasksetPackageReceiptSchema = z.object({\n schemaVersion: z.literal(\"openpond.tasksetPackageReceipt.v1\"),\n teamId: IdSchema, modelProjectId: IdSchema, operationId: IdSchema,\n taskset: TasksetCatalogReleaseRefSchema, packageHash: HashSchema,\n hostedTasksetId: IdSchema, projectEtag: HashSchema,\n project: HostedModelProjectSummarySchema.optional(),\n selection: z.enum([\"select\", \"attach\"]).optional(),\n evaluation: z.object({ taskset: TasksetCatalogReleaseRefSchema, packageHash: HashSchema, hostedTasksetId: IdSchema }).strict().optional(),\n}).strict();\nexport const TasksetPackageReadbackSchema = z.object({\n schemaVersion: z.literal(\"openpond.tasksetPackageReadback.v1\"),\n teamId: IdSchema, modelProjectId: IdSchema, package: TasksetPackageSchema,\n}).strict();\nexport const TasksetReleasePackageReadbackSchema=z.object({\n schemaVersion:z.literal(\"openpond.tasksetReleasePackageReadback.v1\"),\n teamId:IdSchema,release:TasksetCatalogReleaseRefSchema,package:TasksetPackageSchema,\n}).strict();\nexport type TasksetPackagePublication = z.infer<typeof TasksetPackagePublicationSchema>;\nexport type TasksetPackageReceipt = z.infer<typeof TasksetPackageReceiptSchema>;\nexport type TasksetPackageModelConfiguration = z.infer<typeof TasksetPackageModelConfigurationSchema>;\n\nexport class OpenPondTasksetPackageError extends Error {\n constructor(readonly status: number, readonly code: string, message: string) { super(message); this.name = \"OpenPondTasksetPackageError\"; }\n}\n\n/** Private package operations are explicitly scoped to an authorized Model.\n * Catalog inventory remains metadata-only and never calls this client itself. */\nexport class OpenPondTasksetPackageClient {\n readonly #options: { baseUrl: string; apiKey: string; teamId: string; fetch?: typeof globalThis.fetch };\n constructor(options: { baseUrl: string; apiKey: string; teamId: string; fetch?: typeof globalThis.fetch }) {\n const url = new URL(options.baseUrl);\n 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.\");\n this.#options = { ...options, baseUrl: url.toString().replace(/\\/+$/, \"\") };\n }\n\n async publish(input: TasksetPackagePublication, options: { signal?: AbortSignal } = {}): Promise<TasksetPackageReceipt> {\n const request = TasksetPackagePublicationSchema.parse(input);\n validateTasksetPackage(request.package);\n if (request.evaluationPackage) validateTasksetPackage(request.evaluationPackage);\n const receipt = TasksetPackageReceiptSchema.parse(await this.#request(\"\", \"POST\", request, options.signal));\n const release = request.package.taskset;\n if (receipt.teamId !== this.#options.teamId || receipt.modelProjectId !== request.modelProjectId || receipt.operationId !== request.operationId\n || receipt.packageHash !== request.package.contentHash || receipt.taskset.id !== release.id || receipt.taskset.revision !== release.revision || receipt.taskset.contentHash !== release.contentHash) {\n throw new OpenPondTasksetPackageError(502, \"package_receipt_mismatch\", \"Taskset publication receipt did not match the requested package and owner.\");\n }\n if (request.selection !== undefined && receipt.selection !== request.selection) throw new OpenPondTasksetPackageError(502, \"package_receipt_mismatch\", \"Taskset publication did not retain its selection mode.\");\n if (request.evaluationPackage && (!receipt.evaluation\n || receipt.evaluation.packageHash !== request.evaluationPackage.contentHash\n || contentHash(receipt.evaluation.taskset) !== contentHash(learningRef(request.evaluationPackage.taskset)))) {\n throw new OpenPondTasksetPackageError(502, \"package_receipt_mismatch\", \"Taskset publication did not retain the complete selected evaluation package.\");\n }\n if (request.selection === \"attach\" && receipt.projectEtag !== request.expectedProjectEtag) throw new OpenPondTasksetPackageError(502, \"package_receipt_mismatch\", \"Attaching a historical Taskset changed the Model configuration.\");\n if (request.modelConfiguration) {\n const expected = request.modelConfiguration;\n const project = receipt.project;\n const binding = tasksetPackageRewardBinding(request.package);\n const setup = HostedModelProjectTrainingSetupSchema.parse({ ...expected.trainingSetup, tasksetRef: learningRef(release),\n rewardBindingRef: binding ? learningRef(binding) : null,\n tasksetRelease: null });\n if (!project || project.teamId !== this.#options.teamId || project.etag !== receipt.projectEtag\n || ![project.id, project.portableProjectId].includes(request.modelProjectId)\n || project.portableProjectId !== expected.portableProjectId || project.name !== expected.name || project.objective !== expected.objective\n || project.sourceRevision !== expected.sourceRevision || Date.parse(project.sourceUpdatedAt) !== Date.parse(expected.sourceUpdatedAt)\n || contentHash(project.defaultBaseModel) !== contentHash(expected.defaultBaseModel) || project.defaultDestinationId !== expected.defaultDestinationId\n || contentHash(project.trainingSetup) !== contentHash(setup)) {\n throw new OpenPondTasksetPackageError(502, \"package_receipt_mismatch\", \"Taskset publication did not retain the requested Model configuration.\");\n }\n }\n return receipt;\n }\n\n /** Owner-authorized independent Dataset transfer. Callers retain private\n * bytes at the evaluator/server boundary, never in a policy-facing picker. */\n async getByRelease(reference:z.infer<typeof TasksetCatalogReleaseRefSchema>,options:{signal?:AbortSignal;expectedPackageHash?:string}={}):Promise<TasksetPackage> {\n const ref=TasksetCatalogReleaseRefSchema.parse(reference);\n const expectedPackageHash=options.expectedPackageHash===undefined?undefined:HashSchema.parse(options.expectedPackageHash);\n const response=TasksetReleasePackageReadbackSchema.parse(await this.#request(`/releases/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}/package`,\"GET\",undefined,options.signal));\n const value=validateTasksetPackage(response.package),release={id:value.taskset.id,revision:value.taskset.revision,contentHash:value.taskset.contentHash};\n if(response.teamId!==this.#options.teamId||contentHash(response.release)!==contentHash(ref)||contentHash(release)!==contentHash(ref)\n ||expectedPackageHash!==undefined&&value.contentHash!==expectedPackageHash)\n throw new OpenPondTasksetPackageError(502,\"package_readback_mismatch\",\"Independent Dataset package differs from the requested workspace or exact release.\");\n return value;\n }\n\n async get(modelProjectId: string, reference: z.infer<typeof TasksetCatalogReleaseRefSchema>, options: { signal?: AbortSignal; expectedPackageHash?: string } = {}): Promise<TasksetPackage> {\n const project = IdSchema.parse(modelProjectId);\n const ref = TasksetCatalogReleaseRefSchema.parse(reference);\n const expectedPackageHash = options.expectedPackageHash === undefined ? undefined : HashSchema.parse(options.expectedPackageHash);\n const response = TasksetPackageReadbackSchema.parse(await this.#request(`/${encodeURIComponent(project)}/${encodeURIComponent(ref.id)}/${ref.revision}/${ref.contentHash}`, \"GET\", undefined, options.signal));\n const taskset = response.package.taskset;\n 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.\");\n if (expectedPackageHash !== undefined && response.package.contentHash !== expectedPackageHash) throw new OpenPondTasksetPackageError(502, \"package_readback_mismatch\", \"Taskset package did not match the saved publication receipt.\");\n return validateTasksetPackage(response.package);\n }\n\n async #request(path: string, method: string, body: unknown, signal?: AbortSignal): Promise<unknown> {\n const serialized = body === undefined ? undefined : JSON.stringify(body);\n 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.\");\n const response = await (this.#options.fetch ?? globalThis.fetch)(`${this.#options.baseUrl}/v1/taskset-packages${path}`, {\n method, headers: { Authorization: `Bearer ${this.#options.apiKey}`, \"X-OpenPond-Team-Id\": this.#options.teamId, Accept: \"application/json\", ...(serialized ? { \"Content-Type\": \"application/json\" } : {}) },\n body: serialized, signal, redirect: \"error\",\n });\n const reader = response.body?.getReader();\n if (!reader) throw new OpenPondTasksetPackageError(response.status, \"empty_response\", \"Taskset package response was empty.\");\n const decoder = new TextDecoder(\"utf-8\", { fatal: true });\n let bytes = 0;\n let text = \"\";\n try {\n while (true) {\n const chunk = await reader.read();\n if (chunk.done) break;\n bytes += chunk.value.byteLength;\n if (bytes > MAX_TASKSET_PACKAGE_BYTES) throw new OpenPondTasksetPackageError(413, \"package_too_large\", \"Taskset response exceeds the 64 MiB envelope.\");\n text += decoder.decode(chunk.value, { stream: true });\n }\n text += decoder.decode();\n } finally { await reader.cancel(); reader.releaseLock(); }\n const payload: unknown = JSON.parse(text);\n if (!response.ok) {\n const error = z.object({ code: z.string(), message: z.string() }).safeParse(payload);\n throw new OpenPondTasksetPackageError(response.status, error.success ? error.data.code : \"package_request_failed\", error.success ? error.data.message : `Taskset package request failed (${response.status}).`);\n }\n return payload;\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,SAAS,SAAS;AAKlB,SAAS,mBAAmB;AAE5B,IAAM,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AACjD,IAAM,aAAa,EAAE,OAAO,EAAE,MAAM,gBAAgB;AAG7C,IAAM,yCAAyC,6BAA6B,KAAK;AAAA,EACtF,mBAAmB;AAAA,EAAM,MAAM;AAAA,EAAM,WAAW;AAAA,EAAM,kBAAkB;AAAA,EAAM,sBAAsB;AAAA,EACpG,gBAAgB;AAAA,EAAM,iBAAiB;AACzC,CAAC,EAAE,OAAO,EAAE,eAAe,sCAAsC,KAAK,EAAE,YAAY,MAAM,kBAAkB,MAAM,gBAAgB,KAAK,CAAC,EAAE,CAAC,EAAE,OAAO;AAC7I,IAAM,kCAAkC,EAAE,OAAO;AAAA,EACtD,eAAe,EAAE,QAAQ,uCAAuC;AAAA,EAChE,aAAa;AAAA,EAAU,gBAAgB;AAAA,EAAU,qBAAqB,WAAW,SAAS;AAAA,EAC1F,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG;AAAA,EAAG,aAAa,EAAE,OAAO,EAAE,IAAI,GAAK;AAAA,EAC1E,aAAa,EAAE,KAAK,CAAC,kBAAkB,eAAe,qBAAqB,UAAU,WAAW,CAAC;AAAA,EACjG,YAAY,EAAE,KAAK,CAAC,OAAO,OAAO,QAAQ,KAAK,CAAC,EAAE,SAAS;AAAA,EAAG,SAAS;AAAA,EACvE,oBAAoB,uCAAuC,SAAS;AAAA,EACpE,mBAAmB,qBAAqB,SAAS;AAAA,EACjD,WAAW,EAAE,KAAK,CAAC,UAAU,QAAQ,CAAC,EAAE,SAAS;AACnD,CAAC,EAAE,OAAO,EAAE,OAAO,WAAS,MAAM,cAAc,YAAY,MAAM,uBAAuB,QAAW,iEAAiE,EAClK;AAAA,EAAO,WAAS,CAAC,MAAM,qBAAsB,MAAM,uBAAuB,UACtE,MAAM,mBAAmB,cAAc,wBAAwB,QAC/D,YAAY,MAAM,mBAAmB,cAAc,oBAAoB,MAAM,YAAY,YAAY,MAAM,kBAAkB,OAAO,CAAC;AAAA,EAC1I;AAAyF;AACpF,IAAM,8BAA8B,EAAE,OAAO;AAAA,EAClD,eAAe,EAAE,QAAQ,mCAAmC;AAAA,EAC5D,QAAQ;AAAA,EAAU,gBAAgB;AAAA,EAAU,aAAa;AAAA,EACzD,SAAS;AAAA,EAAgC,aAAa;AAAA,EACtD,iBAAiB;AAAA,EAAU,aAAa;AAAA,EACxC,SAAS,gCAAgC,SAAS;AAAA,EAClD,WAAW,EAAE,KAAK,CAAC,UAAU,QAAQ,CAAC,EAAE,SAAS;AAAA,EACjD,YAAY,EAAE,OAAO,EAAE,SAAS,gCAAgC,aAAa,YAAY,iBAAiB,SAAS,CAAC,EAAE,OAAO,EAAE,SAAS;AAC1I,CAAC,EAAE,OAAO;AACH,IAAM,+BAA+B,EAAE,OAAO;AAAA,EACnD,eAAe,EAAE,QAAQ,oCAAoC;AAAA,EAC7D,QAAQ;AAAA,EAAU,gBAAgB;AAAA,EAAU,SAAS;AACvD,CAAC,EAAE,OAAO;AACH,IAAM,sCAAoC,EAAE,OAAO;AAAA,EACxD,eAAc,EAAE,QAAQ,2CAA2C;AAAA,EACnE,QAAO;AAAA,EAAS,SAAQ;AAAA,EAA+B,SAAQ;AACjE,CAAC,EAAE,OAAO;AAKH,IAAM,8BAAN,cAA0C,MAAM;AAAA,EACrD,YAAqB,QAAyB,MAAc,SAAiB;AAAE,UAAM,OAAO;AAAvE;AAAyB;AAAiD,SAAK,OAAO;AAAA,EAA+B;AAAA,EAArH;AAAA,EAAyB;AAChD;AAIO,IAAM,+BAAN,MAAmC;AAAA,EAC/B;AAAA,EACT,YAAY,SAA+F;AACzG,UAAM,MAAM,IAAI,IAAI,QAAQ,OAAO;AACnC,QAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,SAAS,IAAI,QAAQ,KAAK,IAAI,YAAY,IAAI,YAAY,IAAI,UAAU,IAAI,QAAQ,CAAC,QAAQ,OAAO,KAAK,KAAK,CAAC,QAAQ,OAAO,KAAK,EAAG,OAAM,IAAI,MAAM,qFAAqF;AACpQ,SAAK,WAAW,EAAE,GAAG,SAAS,SAAS,IAAI,SAAS,EAAE,QAAQ,QAAQ,EAAE,EAAE;AAAA,EAC5E;AAAA,EAEA,MAAM,QAAQ,OAAkC,UAAoC,CAAC,GAAmC;AACtH,UAAM,UAAU,gCAAgC,MAAM,KAAK;AAC3D,2BAAuB,QAAQ,OAAO;AACtC,QAAI,QAAQ,kBAAmB,wBAAuB,QAAQ,iBAAiB;AAC/E,UAAM,UAAU,4BAA4B,MAAM,MAAM,KAAK,SAAS,IAAI,QAAQ,SAAS,QAAQ,MAAM,CAAC;AAC1G,UAAM,UAAU,QAAQ,QAAQ;AAChC,QAAI,QAAQ,WAAW,KAAK,SAAS,UAAU,QAAQ,mBAAmB,QAAQ,kBAAkB,QAAQ,gBAAgB,QAAQ,eAC/H,QAAQ,gBAAgB,QAAQ,QAAQ,eAAe,QAAQ,QAAQ,OAAO,QAAQ,MAAM,QAAQ,QAAQ,aAAa,QAAQ,YAAY,QAAQ,QAAQ,gBAAgB,QAAQ,aAAa;AACrM,YAAM,IAAI,4BAA4B,KAAK,4BAA4B,4EAA4E;AAAA,IACrJ;AACA,QAAI,QAAQ,cAAc,UAAa,QAAQ,cAAc,QAAQ,UAAW,OAAM,IAAI,4BAA4B,KAAK,4BAA4B,wDAAwD;AAC/M,QAAI,QAAQ,sBAAsB,CAAC,QAAQ,cACtC,QAAQ,WAAW,gBAAgB,QAAQ,kBAAkB,eAC7D,YAAY,QAAQ,WAAW,OAAO,MAAM,YAAY,YAAY,QAAQ,kBAAkB,OAAO,CAAC,IAAI;AAC7G,YAAM,IAAI,4BAA4B,KAAK,4BAA4B,8EAA8E;AAAA,IACvJ;AACA,QAAI,QAAQ,cAAc,YAAY,QAAQ,gBAAgB,QAAQ,oBAAqB,OAAM,IAAI,4BAA4B,KAAK,4BAA4B,iEAAiE;AACnO,QAAI,QAAQ,oBAAoB;AAC9B,YAAM,WAAW,QAAQ;AACzB,YAAM,UAAU,QAAQ;AACxB,YAAM,UAAU,4BAA4B,QAAQ,OAAO;AAC3D,YAAM,QAAQ,sCAAsC,MAAM;AAAA,QAAE,GAAG,SAAS;AAAA,QAAe,YAAY,YAAY,OAAO;AAAA,QACpH,kBAAkB,UAAU,YAAY,OAAO,IAAI;AAAA,QACnD,gBAAgB;AAAA,MAAK,CAAC;AACxB,UAAI,CAAC,WAAW,QAAQ,WAAW,KAAK,SAAS,UAAU,QAAQ,SAAS,QAAQ,eAC/E,CAAC,CAAC,QAAQ,IAAI,QAAQ,iBAAiB,EAAE,SAAS,QAAQ,cAAc,KACxE,QAAQ,sBAAsB,SAAS,qBAAqB,QAAQ,SAAS,SAAS,QAAQ,QAAQ,cAAc,SAAS,aAC7H,QAAQ,mBAAmB,SAAS,kBAAkB,KAAK,MAAM,QAAQ,eAAe,MAAM,KAAK,MAAM,SAAS,eAAe,KACjI,YAAY,QAAQ,gBAAgB,MAAM,YAAY,SAAS,gBAAgB,KAAK,QAAQ,yBAAyB,SAAS,wBAC9H,YAAY,QAAQ,aAAa,MAAM,YAAY,KAAK,GAAG;AAC9D,cAAM,IAAI,4BAA4B,KAAK,4BAA4B,uEAAuE;AAAA,MAChJ;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA,EAIA,MAAM,aAAa,WAAyD,UAA0D,CAAC,GAA2B;AAChK,UAAM,MAAI,+BAA+B,MAAM,SAAS;AACxD,UAAM,sBAAoB,QAAQ,wBAAsB,SAAU,SAAU,WAAW,MAAM,QAAQ,mBAAmB;AACxH,UAAM,WAAS,oCAAoC,MAAM,MAAM,KAAK,SAAS,aAAa,mBAAmB,IAAI,EAAE,CAAC,IAAI,IAAI,QAAQ,IAAI,IAAI,WAAW,YAAW,OAAM,QAAU,QAAQ,MAAM,CAAC;AACjM,UAAM,QAAM,uBAAuB,SAAS,OAAO,GAAE,UAAQ,EAAC,IAAG,MAAM,QAAQ,IAAG,UAAS,MAAM,QAAQ,UAAS,aAAY,MAAM,QAAQ,YAAW;AACvJ,QAAG,SAAS,WAAS,KAAK,SAAS,UAAQ,YAAY,SAAS,OAAO,MAAI,YAAY,GAAG,KAAG,YAAY,OAAO,MAAI,YAAY,GAAG,KAC/H,wBAAsB,UAAW,MAAM,gBAAc;AACvD,YAAM,IAAI,4BAA4B,KAAI,6BAA4B,oFAAoF;AAC5J,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,IAAI,gBAAwB,WAA2D,UAAkE,CAAC,GAA4B;AAC1L,UAAM,UAAU,SAAS,MAAM,cAAc;AAC7C,UAAM,MAAM,+BAA+B,MAAM,SAAS;AAC1D,UAAM,sBAAsB,QAAQ,wBAAwB,SAAY,SAAY,WAAW,MAAM,QAAQ,mBAAmB;AAChI,UAAM,WAAW,6BAA6B,MAAM,MAAM,KAAK,SAAS,IAAI,mBAAmB,OAAO,CAAC,IAAI,mBAAmB,IAAI,EAAE,CAAC,IAAI,IAAI,QAAQ,IAAI,IAAI,WAAW,IAAI,OAAO,QAAW,QAAQ,MAAM,CAAC;AAC7M,UAAM,UAAU,SAAS,QAAQ;AACjC,QAAI,SAAS,WAAW,KAAK,SAAS,UAAU,SAAS,mBAAmB,WAAW,QAAQ,OAAO,IAAI,MAAM,QAAQ,aAAa,IAAI,YAAY,QAAQ,gBAAgB,IAAI,YAAa,OAAM,IAAI,4BAA4B,KAAK,6BAA6B,gEAAgE;AACtU,QAAI,wBAAwB,UAAa,SAAS,QAAQ,gBAAgB,oBAAqB,OAAM,IAAI,4BAA4B,KAAK,6BAA6B,8DAA8D;AACrO,WAAO,uBAAuB,SAAS,OAAO;AAAA,EAChD;AAAA,EAEA,MAAM,SAAS,MAAc,QAAgB,MAAe,QAAwC;AAClG,UAAM,aAAa,SAAS,SAAY,SAAY,KAAK,UAAU,IAAI;AACvE,QAAI,cAAc,IAAI,YAAY,EAAE,OAAO,UAAU,EAAE,aAAa,0BAA2B,OAAM,IAAI,4BAA4B,KAAK,qBAAqB,kDAAkD;AACjN,UAAM,WAAW,OAAO,KAAK,SAAS,SAAS,WAAW,OAAO,GAAG,KAAK,SAAS,OAAO,uBAAuB,IAAI,IAAI;AAAA,MACtH;AAAA,MAAQ,SAAS,EAAE,eAAe,UAAU,KAAK,SAAS,MAAM,IAAI,sBAAsB,KAAK,SAAS,QAAQ,QAAQ,oBAAoB,GAAI,aAAa,EAAE,gBAAgB,mBAAmB,IAAI,CAAC,EAAG;AAAA,MAC1M,MAAM;AAAA,MAAY;AAAA,MAAQ,UAAU;AAAA,IACtC,CAAC;AACD,UAAM,SAAS,SAAS,MAAM,UAAU;AACxC,QAAI,CAAC,OAAQ,OAAM,IAAI,4BAA4B,SAAS,QAAQ,kBAAkB,qCAAqC;AAC3H,UAAM,UAAU,IAAI,YAAY,SAAS,EAAE,OAAO,KAAK,CAAC;AACxD,QAAI,QAAQ;AACZ,QAAI,OAAO;AACX,QAAI;AACF,aAAO,MAAM;AACX,cAAM,QAAQ,MAAM,OAAO,KAAK;AAChC,YAAI,MAAM,KAAM;AAChB,iBAAS,MAAM,MAAM;AACrB,YAAI,QAAQ,0BAA2B,OAAM,IAAI,4BAA4B,KAAK,qBAAqB,+CAA+C;AACtJ,gBAAQ,QAAQ,OAAO,MAAM,OAAO,EAAE,QAAQ,KAAK,CAAC;AAAA,MACtD;AACA,cAAQ,QAAQ,OAAO;AAAA,IACzB,UAAE;AAAU,YAAM,OAAO,OAAO;AAAG,aAAO,YAAY;AAAA,IAAG;AACzD,UAAM,UAAmB,KAAK,MAAM,IAAI;AACxC,QAAI,CAAC,SAAS,IAAI;AAChB,YAAM,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,UAAU,OAAO;AACnF,YAAM,IAAI,4BAA4B,SAAS,QAAQ,MAAM,UAAU,MAAM,KAAK,OAAO,0BAA0B,MAAM,UAAU,MAAM,KAAK,UAAU,mCAAmC,SAAS,MAAM,IAAI;AAAA,IAChN;AACA,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-CMWZZZGW.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"sources":["../src/taskset-package-grader-projection.ts","../src/taskset-package-projection.ts"],"sourcesContent":["import { compileBoundGraders, resolveBoundRewards, type RewardBinding, type RewardRelease } from \"@openpond/evals/rewards\";\nimport { learningRef, verifyLearningTextAsset, RewardFixtureAuthoringFieldsSchema, type LearningTextAsset } from \"@openpond/evals/learning\";\nimport type { GraderSpec } from \"./taskset-draft-core.js\";\nimport { GraderSpecSchema } from \"./taskset-draft-core.js\";\nimport { decodeTasksetPackageFile, type TasksetPackage } from \"./taskset-package-contracts.js\";\nimport { z } from \"zod\";\n\n/** Project an ordinary portable package without inventing a Reward binding. */\nexport function importedPackageGraders(value: TasksetPackage) {\n const authoring = value.taskset.metadata.ordinaryAuthoring as { judgeCalibrationFixtures?: unknown } | undefined;\n const calibrationFixtures = z.record(z.string(), z.array(z.string().min(1)).max(100_000)).parse(authoring?.judgeCalibrationFixtures ?? {});\n return value.taskset.graders.map(grader => {\n const base = { ...grader, label: grader.id, metadata: { portableGrader: grader } };\n if (grader.kind === \"custom_verifier\") return GraderSpecSchema.parse({ ...base,\n module: grader.verifierRef.path, exportName: grader.exportName ?? \"verify\",\n metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef } });\n if (grader.kind === \"human\" || grader.kind === \"model_judge\") {\n const file = value.files.find(file => file.asset.id === grader.rubricRef.id);\n if (!file) throw new Error(`Imported rubric is missing: ${grader.id}.`);\n const rubric = new TextDecoder(\"utf-8\", { fatal: true }).decode(decodeTasksetPackageFile(file));\n const metadata = { ...base.metadata, portableRubricRef: grader.rubricRef };\n if (grader.kind === \"human\") return GraderSpecSchema.parse({ ...base, rubric, metadata });\n if (!grader.model) throw new Error(`Imported judge ${grader.id} requires its declared model before local preparation.`);\n return GraderSpecSchema.parse({ ...base, rubric, metadata, judge: grader.model, temperature: grader.temperature ?? 0,\n calibrationStatus: \"pending\", calibrationFixtureRefs: calibrationFixtures[grader.id] ?? [] });\n }\n return GraderSpecSchema.parse({ ...base, kind: grader.kind === \"artifact\" ? \"file\" : grader.kind,\n config: grader.kind === \"artifact\" ? { ...grader.config, ...(grader.config.refIncludes === undefined ? {} : { pathIncludes: grader.config.refIncludes }) } : grader.config });\n });\n}\n\nexport function projectLearningBatchGraders(binding: RewardBinding, rewards: RewardRelease[], assets: LearningTextAsset[] = []): GraderSpec[] {\n const resolved = resolveBoundRewards(binding, rewards);\n return compileBoundGraders(binding, rewards).map((grader) => {\n const reward = resolved.find(({ source }) => source.graderId === grader.id)!.reward;\n const base = { ...grader, label: reward.name, metadata: { rewardBinding: learningRef(binding) } };\n if (grader.kind === \"model_judge\") {\n if (!grader.model || grader.calibrationStatus !== \"passed\" || !reward.calibrationCheckRef || !reward.fixtureSetRef) throw new Error(`Reward ${grader.id} needs a retained passing calibration check before preparation.`);\n const rubric = assets.find(asset => asset.id === grader.rubricRef.id);\n const fixtures = assets.find(asset => asset.id === reward.fixtureSetRef!.id);\n if (!rubric || !fixtures) throw new Error(`Reward ${grader.id} is missing its immutable rubric or calibration fixtures.`);\n const fields = RewardFixtureAuthoringFieldsSchema.array().min(1).max(50).parse(JSON.parse(verifyLearningTextAsset(fixtures, reward.fixtureSetRef)));\n return GraderSpecSchema.parse({ ...base, rubric: verifyLearningTextAsset(rubric, grader.rubricRef), judge: grader.model,\n temperature: grader.temperature ?? 0, calibrationFixtureRefs: fields.map(fixture => fixture.id),\n metadata: { ...base.metadata, portableGrader: grader, portableRubricRef: grader.rubricRef,\n calibrationEvidenceHash: reward.calibrationCheckRef.contentHash, calibrationCheckRef: reward.calibrationCheckRef },\n });\n }\n if (grader.kind === \"custom_verifier\") return GraderSpecSchema.parse({ ...base,\n module: grader.verifierRef.path, exportName: grader.exportName ?? \"verify\",\n metadata: { ...base.metadata, portableVerifierRef: grader.verifierRef },\n });\n if (grader.kind === \"human\") {\n const asset = assets.find((asset) => asset.id === grader.rubricRef.id);\n if (!asset) throw new Error(`Reward ${grader.id} is missing its immutable rubric.`);\n return GraderSpecSchema.parse({ ...base, rubric: verifyLearningTextAsset(asset, grader.rubricRef),\n metadata: { ...base.metadata, portableGrader: grader, portableRubricRef: grader.rubricRef },\n });\n }\n return GraderSpecSchema.parse({ ...base, kind: grader.kind === \"artifact\" ? \"file\" : grader.kind });\n });\n}\n\nexport function learningVerifierModule(hash: string) { return `graders/reward-${hash}.js`; }\n","import { GraderFixtureSchema, TasksetEnvironmentResourceSchema, TasksetSourceRefSchema } from \"./taskset-draft-core.js\";\nimport { TasksetSchema, type GeneratedTaskFile } from \"./taskset-authored-contracts.js\";\nimport { contentHash } from \"@openpond/harness\";\nimport { z } from \"zod\";\nimport { learningRef, taskBatchPackageMetadata, verifyLearningTextAsset } from \"@openpond/evals/learning\";\nimport { computeTasksetHash } from \"./taskset-authored-validation.js\";\nimport { createTasksetDraft } from \"./taskset-draft-authoring.js\";\nimport { projectLearningBatchGraders, importedPackageGraders } from \"./taskset-package-grader-projection.js\";\nimport { decodeTasksetPackageFile, resolveTasksetPackageInstructions, validateTasksetPackage, type TasksetPackage } from \"./taskset-package-contracts.js\";\n\n/** Local identity includes Profile and provenance; portable identity stays in\n * the receipt. Downloading does not approve targets, privacy or licensing. */\nexport function prepareImportedTasksetPackage(input: {\n package: TasksetPackage; profileId: string; name: string; createdAt: string;\n}) {\n const value = validateTasksetPackage(input.package);\n const release = value.taskset;\n const resources = value.modelResources;\n const learning = value.learningResources ? taskBatchPackageMetadata(release) : undefined;\n const source = TasksetSourceRefSchema.parse({\n schemaVersion: \"openpond.uploadedFileDatasetSource.v1\", kind: \"uploaded_file\",\n id: `package-source-${contentHash({ profileId: input.profileId, packageHash: value.contentHash })}`,\n profileId: input.profileId, title: input.name, sourceHash: value.contentHash, occurredAt: input.createdAt,\n licensingStatus: \"pending\", secretScanStatus: \"pending\", piiScanStatus: \"pending\",\n originalFileNames: [\"taskset-package.json\"], mediaTypes: [\"application/json\"], sourceFileHashes: [value.contentHash],\n totalBytes: new TextEncoder().encode(JSON.stringify(value)).byteLength, parserVersion: \"openpond.tasksetPackage.v1\", metadata: {},\n });\n const draft = createTasksetDraft({ profileId: input.profileId, id: `${release.id}-import`, name: input.name, now: input.createdAt });\n const files: GeneratedTaskFile[] = [];\n for (const grader of release.graders) if (grader.kind === \"custom_verifier\") {\n const asset = resources?.assets.find(asset => asset.id === grader.verifierRef.id);\n const file = value.files.find(file => file.asset.id === grader.verifierRef.id);\n if (!file) throw new Error(`Imported verifier source is missing: ${grader.id}.`);\n const name = grader.verifierRef.path;\n if (!files.some(file => file.path === name)) files.push({ path: name, role: \"verifier\", content: asset ? verifyLearningTextAsset(asset, grader.verifierRef) : new TextDecoder(\"utf-8\", { fatal: true }).decode(decodeTasksetPackageFile(file)) });\n }\n const authoring = (release.metadata.ordinaryAuthoring ?? release.metadata.starterAuthoring) as { graderFixtures?: unknown } | undefined;\n const fixtures = GraderFixtureSchema.array().max(100_000).parse(authoring?.graderFixtures ?? []);\n const kind = release.environment.kind === \"text\" ? \"chat\" : release.environment.kind === \"custom_program\" ? \"program\" : release.environment.kind;\n const stagingPaths = z.record(z.string(), z.record(z.string(), z.string())).parse(release.metadata.workAssetStagingPaths ?? {});\n const projected = TasksetSchema.parse({\n schemaVersion: \"openpond.taskset.v1\", id: release.id, revision: release.revision,\n profileId: input.profileId, profileRelease: null, createImproveRunId: null,\n name: input.name, objective: resolveTasksetPackageInstructions(value), status: \"needs_review\",\n sourceRefs: [source], datasetArtifact: null, policy: release.policy,\n environment: { ...draft.environment, kind, entrypoint: release.environment.entrypoint,\n resources: TasksetEnvironmentResourceSchema.array().max(10_000).parse(release.metadata.environmentResources ?? []),\n stateful: release.environment.stateful, deterministicSeeds: release.environment.deterministicSeeds,\n toolNames: release.tools.map(tool => tool.name), defaultTimeoutMs: release.environment.defaultTimeoutMs,\n networkPolicy: release.environment.networkPolicy, metadata: {\n runtimeSourceTasksetId: tasksetPackageSourceId(input.profileId, value.contentHash),\n portableEnvironment: release.environment, portableTools: release.tools,\n portableExecutionResources: { environment: value.environment, verifierSet: value.verifierSet },\n } },\n capabilities: { ...draft.capabilities, taskKind: kind === \"chat\" ? \"chat\" : kind === \"program\" ? \"custom_program\" : \"single_agent\",\n compatibleMethods: [\"none\"], requiresTools: release.tools.length > 0, requiresState: release.environment.stateful,\n rewardKinds: [...new Set(release.graders.map(grader => grader.kind === \"human\" ? \"human\" : grader.kind === \"model_judge\" ? \"model_judge\" : \"deterministic\"))],\n },\n tasks: release.tasks.map(task => ({ ...task, schemaVersion: \"openpond.taskData.v1\", sourceRefs: [source.id],\n assets: [...new Map([...task.artifactRefs, ...(task.requiredOutputs ?? []).flatMap(output => output.submissionMode === \"structured_json\" && output.schemaRef ? [output.schemaRef] : [])].map(asset => [asset.id, asset])).values()].map(asset => ({ id: asset.id, sourceRefId: source.id, artifactRef: asset.path,\n fileName: asset.path.split(\"/\").at(-1)!, ...(stagingPaths[task.id]?.[asset.id] ? { stagingPath: stagingPaths[task.id]![asset.id] } : {}),\n mediaType: asset.mediaType, sha256: asset.contentHash,\n sizeBytes: asset.sizeBytes, split: task.split, metadata: { portableAsset: asset } })),\n ...(task.requiredOutputs ? { requiredOutputs: task.requiredOutputs.map(output => ({ ...output,\n schemaRef: output.schemaRef?.id ?? null, maxBytes: output.maxBytes ?? undefined })) } : {}),\n metadata: { portableTaskRecord: task, exampleOrigin: \"imported\" },\n })),\n graders: resources ? projectLearningBatchGraders(resources.rewardBinding, resources.rewards, resources.assets)\n : learning ? projectLearningBatchGraders(learning.binding, learning.rewards, value.learningResources!.assets) : importedPackageGraders(value),\n graderFixtures: fixtures, learningSignals: draft.learningSignals,\n ...(release.metrics ? { metrics: release.metrics } : {}),\n authoringProvenance: { schemaVersion: \"openpond.taskAuthoringProvenance.v1\", model: null, modelConfig: {},\n skillHash: contentHash(\"openpond-package-import-v1\"), promptTemplateVersion: \"package-import-v1\", buildIntent: \"discovery\",\n buildSpecification: null, evidenceHashes: [value.contentHash], tasksetSdkVersion: \"package-import-v1\",\n sourceCommit: null, repairHistory: [], createdAt: input.createdAt },\n readiness: null, contentHash: \"00000000\", createdAt: input.createdAt, updatedAt: input.createdAt,\n metadata: { importedPackageHash: value.contentHash,\n tasksetOutputContract: release.metadata.tasksetOutputContract ?? null,\n ...(learning ? { learning } : {}),\n portableFileInventory: value.files.map(file => ({ asset: file.asset, sourcePath: file.asset.path })),\n ...(resources ? { taskDefinition: learningRef(resources.taskDefinition),\n rewardBinding: learningRef(resources.rewardBinding), rewardExecution: { binding: resources.rewardBinding, rewards: resources.rewards } } : {}),\n portableCapabilities: release.capabilities, derivedPortableMetadata: release.metadata,\n ...(release.metadata.modelTasksetDerivation ? { modelTasksetDerivation: release.metadata.modelTasksetDerivation } : {}),\n },\n });\n return { package: value, taskset: TasksetSchema.parse({ ...projected, contentHash: computeTasksetHash(projected) }), generatedFiles: files };\n}\n\nexport type PreparedImportedTasksetPackage = ReturnType<typeof prepareImportedTasksetPackage> & { reuseExisting?: boolean };\n\n/** Stable source identity; it is never an authorization or object-store pointer. */\nexport function tasksetPackageSourceId(profileId: string, packageHash: string): string {\n return `package-${contentHash({ profileId, packageHash })}`;\n}\n"],"mappings":"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","names":["file","asset","z","learningRef","verifyLearningTextAsset","asset","file","verifyLearningTextAsset","z","learningRef"]}

package/dist/chunk-GAIDBPFY.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"sources":["../src/taskset-draft-document.ts","../src/taskset-authored-contracts.ts","../src/taskset-draft-authoring.ts","../src/taskset-authored-validation.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { TasksetMetricPolicySchema } from \"@openpond/evals/metrics\";\nimport { ModelTasksetDraftPreparationSchema } from \"./model-taskset-authoring-contracts.js\";\n\nimport { DatasetArtifactManifestSchema } from \"./taskset-draft-dataset-artifacts.js\";\nimport {\n GraderFixtureSchema,\n GraderSpecSchema,\n LearningSignalInventorySchema,\n TaskDataRecordSchema,\n TaskPolicyBoundarySchema,\n TasksetBenchmarkBindingSchema,\n TasksetCapabilityManifestSchema,\n TasksetEnvironmentContractSchema,\n TasksetPreferenceComparisonBindingSchema,\n TasksetPurposeSchema,\n TasksetSourceRefSchema,\n} from \"./taskset-draft-core.js\";\n\nconst IdSchema = z.string().trim().min(1).max(240);\nconst TimestampSchema = z.string().trim().min(1);\nconst HashSchema = z.string().trim().min(8).max(256);\nconst CodeIdentifierSchema = z.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/);\nconst MetadataSchema = z.record(z.string(), z.unknown()).default({});\n\nfunction safeRelativeFilePath(value: string): boolean {\n const normalized = value.trim().replaceAll(\"\\\\\", \"/\");\n if (\n !normalized\n || normalized.startsWith(\"/\")\n || normalized === \".\"\n || normalized === \"..\"\n ) {\n return false;\n }\n return !normalized.split(\"/\").some((segment) =>\n !segment || segment === \".\" || segment === \"..\"\n );\n}\n\nexport const TaskDataDraftSchema = TaskDataRecordSchema.extend({\n sourceRefs: z.array(IdSchema).max(100).default([]),\n});\n\nexport const TasksetDraftStatusSchema = z.enum([\n \"draft\",\n \"validating\",\n \"needs_review\",\n \"published\",\n]);\n\nexport const TasksetDraftReviewPolicySchema = z.object({\n enabled: z.boolean(),\n candidateCount: z.number().int().min(2).max(4),\n minimumSamples: z.number().int().min(1).max(10_000).default(100),\n allowTies: z.boolean(),\n allowRejectAll: z.boolean(),\n rubric: z.string().trim().max(50_000),\n criteria: z.array(z.object({\n id: IdSchema,\n label: z.string().trim().min(1).max(500),\n description: z.string().trim().max(10_000),\n weight: z.number().nonnegative().max(1_000),\n })).max(100),\n});\n\nexport const TasksetDraftOutputContractSchema = z.object({\n mode: z.enum([\"text\", \"structured_json\", \"artifacts\"]),\n jsonSchema: z.record(z.string(), z.unknown()).nullable(),\n renderer: z.object({\n module: z.string().trim().min(1).max(1_000)\n .refine(safeRelativeFilePath, \"Renderer modules must use a safe relative path.\"),\n exportName: CodeIdentifierSchema,\n configRef: z.string().trim().min(1).max(1_000)\n .refine(safeRelativeFilePath, \"Renderer configuration must use a safe relative path.\")\n .nullable()\n .default(null),\n }).nullable(),\n}).superRefine((output, context) => {\n if (output.mode === \"structured_json\" && !output.jsonSchema) {\n context.addIssue({\n code: \"custom\",\n message: \"Structured JSON output requires a JSON Schema.\",\n path: [\"jsonSchema\"],\n });\n }\n if (output.mode === \"text\" && output.renderer) {\n context.addIssue({\n code: \"custom\",\n message: \"Text output cannot configure an artifact renderer.\",\n path: [\"renderer\"],\n });\n }\n});\n\nexport const TasksetDraftSchema = z.object({\n schemaVersion: z.literal(\"openpond.tasksetDraft.v1\"),\n id: IdSchema,\n revision: z.number().int().positive(),\n profileId: IdSchema,\n modelScope: z.object({\n modelId: IdSchema,\n expectedModelRevision: z.number().int().positive(),\n source: ModelTasksetDraftPreparationSchema.optional(),\n }).strict().nullable().default(null),\n name: z.string().trim().max(500),\n objective: z.string().trim().max(20_000),\n purpose: TasksetPurposeSchema.default(\"general\"),\n benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),\n preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),\n status: TasksetDraftStatusSchema,\n sourceRefs: z.array(TasksetSourceRefSchema).max(100_000).default([]),\n datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),\n policy: TaskPolicyBoundarySchema,\n environment: TasksetEnvironmentContractSchema,\n output: TasksetDraftOutputContractSchema.default({\n mode: \"text\",\n jsonSchema: null,\n renderer: null,\n }),\n capabilities: TasksetCapabilityManifestSchema,\n metrics: TasksetMetricPolicySchema,\n review: TasksetDraftReviewPolicySchema,\n tasks: z.array(TaskDataDraftSchema).max(1_000_000).default([]),\n graders: z.array(GraderSpecSchema).max(1_000).default([]),\n graderFixtures: z.array(GraderFixtureSchema).max(100_000).default([]),\n learningSignals: LearningSignalInventorySchema,\n publishedTasksetRef: z.object({\n id: IdSchema,\n revision: z.number().int().positive(),\n contentHash: HashSchema,\n }).nullable(),\n createdAt: TimestampSchema,\n updatedAt: TimestampSchema,\n metadata: MetadataSchema,\n}).superRefine((draft, context) => {\n if (draft.purpose === \"benchmark\" && !draft.benchmark) {\n context.addIssue({\n code: \"custom\",\n message: \"Benchmark drafts require an immutable benchmark binding.\",\n path: [\"benchmark\"],\n });\n }\n if (draft.purpose !== \"benchmark\" && draft.benchmark) {\n context.addIssue({\n code: \"custom\",\n message: \"Only benchmark drafts may carry a benchmark binding.\",\n path: [\"benchmark\"],\n });\n }\n if (draft.datasetArtifact && draft.tasks.length > 0) {\n context.addIssue({\n code: \"custom\",\n message: \"Artifact-backed drafts may not duplicate canonical rows inline.\",\n path: [\"tasks\"],\n });\n }\n if (draft.status === \"published\" && !draft.publishedTasksetRef) {\n context.addIssue({\n code: \"custom\",\n message: \"Published drafts require an immutable Taskset reference.\",\n path: [\"publishedTasksetRef\"],\n });\n }\n});\n\nexport type TaskDataDraft = z.infer<typeof TaskDataDraftSchema>;\nexport type TasksetDraftStatus = z.infer<typeof TasksetDraftStatusSchema>;\nexport type TasksetDraftReviewPolicy = z.infer<typeof TasksetDraftReviewPolicySchema>;\nexport type TasksetDraftOutputContract = z.infer<typeof TasksetDraftOutputContractSchema>;\nexport type TasksetDraft = z.infer<typeof TasksetDraftSchema>;\n","import { z } from \"zod\";\nimport { VersionedReleaseRefSchema } from \"@openpond/harness\";\nimport { ChatModelRefSchema } from \"@openpond/harness/models\";\nimport { TasksetMetricPolicySchema } from \"@openpond/evals/metrics\";\nimport { DatasetArtifactManifestSchema } from \"./taskset-draft-dataset-artifacts.js\";\nimport {\n TasksetPurposeSchema,\n TasksetBenchmarkBindingSchema,\n TasksetPreferenceComparisonBindingSchema,\n TasksetSourceRefSchema,\n TaskPolicyBoundarySchema,\n TasksetEnvironmentContractSchema,\n TasksetCapabilityManifestSchema,\n TaskDataRecordSchema,\n GraderSpecSchema,\n GraderFixtureSchema,\n LearningSignalInventorySchema,\n type TasksetSourceRef, type TrainingSourceRef,\n} from \"./taskset-draft-core.js\";\n\nconst IdSchema = z.string().trim().min(1).max(240);\nconst TimestampSchema = z.string().trim().min(1);\nconst HashSchema = z.string().trim().min(8).max(256);\nconst MetadataSchema = z.record(z.string(), z.unknown()).default({});\nconst NullableIdSchema = IdSchema.nullable();\n\nexport const TASKSET_WORK_TOOL_NAMES = [\n \"work_capabilities\",\n \"work_environment\",\n \"work_list_files\",\n \"work_read_file\",\n \"work_read_document\",\n \"work_write_file\",\n \"work_write_docx\",\n \"work_edit_file\",\n \"work_delete_file\",\n \"work_exec\",\n \"work_save_output\",\n \"work_stop\",\n] as const;\n\nexport const TasksetStatusSchema = z.enum([\n \"draft\",\n \"awaiting_disclosure_approval\",\n \"awaiting_materialization_approval\",\n \"materializing\",\n \"validating\",\n \"needs_review\",\n \"baselining\",\n \"ready\",\n \"blocked\",\n \"failed\",\n \"archived\",\n]);\n\nexport const DatasetBuildIntentSchema = z.enum([\n \"demonstrations\",\n \"preferences\",\n \"verifiable_reward\",\n \"rubric\",\n \"discovery\",\n]);\n\nconst DatasetEvidenceTextSchema = z.string().trim().max(100_000);\n\nexport const DatasetBuildSpecificationSchema = z.discriminatedUnion(\"kind\", [\n z.object({\n kind: z.literal(\"demonstrations\"),\n behavior: DatasetEvidenceTextSchema,\n examples: z.array(z.object({\n id: IdSchema,\n prompt: DatasetEvidenceTextSchema,\n response: DatasetEvidenceTextSchema,\n })).max(1_000).default([]),\n }),\n z.object({\n kind: z.literal(\"preferences\"),\n preference: DatasetEvidenceTextSchema,\n pairs: z.array(z.object({\n id: IdSchema,\n prompt: DatasetEvidenceTextSchema,\n chosen: DatasetEvidenceTextSchema,\n rejected: DatasetEvidenceTextSchema,\n rationale: DatasetEvidenceTextSchema,\n })).max(1_000).default([]),\n }),\n z.object({\n kind: z.literal(\"verifiable_reward\"),\n task: DatasetEvidenceTextSchema,\n rules: z.array(z.object({\n id: IdSchema,\n points: z.number().finite(),\n condition: DatasetEvidenceTextSchema,\n })).max(1_000).default([]),\n otherwisePoints: z.number().finite().default(0),\n }),\n z.object({\n kind: z.literal(\"rubric\"),\n task: DatasetEvidenceTextSchema,\n criteria: z.array(z.object({\n id: IdSchema,\n label: z.string().trim().max(500),\n description: DatasetEvidenceTextSchema,\n })).max(1_000).default([]),\n positiveExample: DatasetEvidenceTextSchema,\n negativeExample: DatasetEvidenceTextSchema,\n boundaryExample: DatasetEvidenceTextSchema,\n }),\n]);\n\nexport const GeneratedTaskFileSchema = z.object({\n path: z.string().trim().min(1).max(1_000),\n role: z.enum([\"environment\", \"verifier\", \"fixture\"]),\n content: z.string().max(250_000),\n});\n\nexport const TrainingPathRecommendationSchema = z.object({\n primaryMethod: z.enum([\"sft\", \"dpo\", \"grpo\", \"ppo\", \"sdft\", \"opsd\", \"sdpo\"]),\n bootstrap: z.object({\n method: z.literal(\"sft\"),\n purpose: z.literal(\"trajectory_bootstrap\"),\n demonstrationRefs: z.array(IdSchema).min(1).max(100_000),\n limitations: z.array(z.string().trim().min(1).max(5_000)).min(1).max(100),\n }).nullable(),\n});\n\nexport const TrainingMethodReadinessReasonCodeSchema = z.enum([\n \"taskset_not_ready\",\n \"demonstrations_missing\",\n \"preference_pairs_missing\",\n \"preference_pairs_invalid\",\n \"executable_reward_missing\",\n \"reward_not_calibrated\",\n \"reward_model_missing\",\n \"value_model_required\",\n \"frozen_eval_missing\",\n]);\n\nexport const TrainingMethodReadinessSchema = z.object({\n method: z.enum([\"sft\", \"dpo\", \"grpo\", \"ppo\"]),\n status: z.enum([\"recommended\", \"compatible\", \"needs_dataset_work\"]),\n reasonCodes: z.array(TrainingMethodReadinessReasonCodeSchema).default([]),\n reasons: z.array(z.string().trim().min(1).max(5_000)).default([]),\n});\n\nexport const TasksetReadinessFindingSchema = z.object({\n code: IdSchema,\n message: z.string().trim().min(1).max(5_000),\n path: z.string().trim().max(2_000).nullable(),\n});\n\nexport const TasksetReadinessReportSchema = z.object({\n schemaVersion: z.literal(\"openpond.tasksetReadiness.v1\"),\n tasksetId: IdSchema,\n tasksetHash: HashSchema,\n ready: z.boolean(),\n recommendedMethod: z.enum([\"none\", \"retrieval\", \"sft\", \"dpo\", \"grpo\", \"ppo\", \"sdft\", \"opd\", \"opsd\", \"sdpo\"]),\n trainingPath: TrainingPathRecommendationSchema.nullable().default(null),\n methodReadiness: z.array(TrainingMethodReadinessSchema).default([]),\n compatibleDestinationClasses: z.array(\n z.enum([\"export\", \"custom\", \"hosted_managed\"]),\n ),\n blockers: z.array(TasksetReadinessFindingSchema).default([]),\n advisories: z.array(TasksetReadinessFindingSchema).default([]),\n warnings: z.array(z.string().trim().min(1).max(5_000)).default([]),\n generatedAt: TimestampSchema,\n});\n\nexport const AuthoringRepairSchema = z.object({ attempt: z.number().int().positive(), summary: z.string().trim().min(1).max(5_000), createdAt: TimestampSchema });\n\nexport const AuthoringProvenanceSchema = z.object({\n schemaVersion: z.literal(\"openpond.taskAuthoringProvenance.v1\"),\n model: ChatModelRefSchema.nullable(),\n modelConfig: MetadataSchema,\n skillHash: HashSchema,\n promptTemplateVersion: z.string().trim().min(1).max(200),\n buildIntent: DatasetBuildIntentSchema.default(\"demonstrations\"),\n buildSpecification: DatasetBuildSpecificationSchema.nullable().default(null),\n evidenceHashes: z.array(HashSchema).max(100_000),\n tasksetSdkVersion: z.string().trim().min(1).max(100),\n sourceCommit: z.string().trim().min(1).max(256).nullable(),\n repairHistory: z.array(AuthoringRepairSchema).max(1_000),\n createdAt: TimestampSchema,\n});\n\nexport const TasksetSchema = z.object({\n schemaVersion: z.literal(\"openpond.taskset.v1\"),\n id: IdSchema,\n revision: z.number().int().positive().default(1),\n profileId: IdSchema,\n profileRelease: VersionedReleaseRefSchema.nullable().optional(),\n createImproveRunId: NullableIdSchema.default(null),\n name: z.string().trim().min(1).max(500),\n // Portable tasks may carry all instructions in their individual inputs.\n // Preserve an absent package prompt; draft publication validates its objective.\n objective: z.string().trim().max(20_000),\n purpose: TasksetPurposeSchema.default(\"general\"),\n benchmark: TasksetBenchmarkBindingSchema.nullable().default(null),\n preferenceComparison: TasksetPreferenceComparisonBindingSchema.nullable().default(null),\n status: TasksetStatusSchema,\n sourceRefs: z.array(TasksetSourceRefSchema).min(1).max(100_000),\n datasetArtifact: DatasetArtifactManifestSchema.nullable().optional(),\n policy: TaskPolicyBoundarySchema,\n environment: TasksetEnvironmentContractSchema,\n capabilities: TasksetCapabilityManifestSchema,\n metrics: TasksetMetricPolicySchema.optional(),\n tasks: z.array(TaskDataRecordSchema).max(1_000_000),\n graders: z.array(GraderSpecSchema).max(1_000),\n // Imported releases are inspectable before local calibration. Admission\n // requires real fixtures separately in validateTaskset.\n graderFixtures: z.array(GraderFixtureSchema).max(100_000),\n learningSignals: LearningSignalInventorySchema,\n authoringProvenance: AuthoringProvenanceSchema,\n readiness: TasksetReadinessReportSchema.nullable(),\n contentHash: HashSchema,\n createdAt: TimestampSchema,\n updatedAt: TimestampSchema,\n metadata: MetadataSchema,\n}).superRefine((taskset, context) => {\n if (taskset.purpose === \"benchmark\" && !taskset.benchmark) {\n context.addIssue({\n code: \"custom\",\n message: \"Benchmark Tasksets require an immutable benchmark binding.\",\n path: [\"benchmark\"],\n });\n }\n if (taskset.purpose !== \"benchmark\" && taskset.benchmark) {\n context.addIssue({\n code: \"custom\",\n message: \"Only benchmark Tasksets may carry a benchmark binding.\",\n path: [\"benchmark\"],\n });\n }\n if (taskset.datasetArtifact && taskset.tasks.length > 0) {\n context.addIssue({\n code: \"custom\",\n message:\n \"Artifact-backed Tasksets may not duplicate canonical rows inline.\",\n path: [\"tasks\"],\n });\n }\n if (!taskset.datasetArtifact && taskset.tasks.length === 0) {\n context.addIssue({\n code: \"custom\",\n message: \"A Taskset requires inline tasks or a Dataset artifact manifest.\",\n path: [\"tasks\"],\n });\n }\n});\n\nexport type DatasetBuildIntent = z.infer<typeof DatasetBuildIntentSchema>;\nexport type DatasetBuildSpecification = z.infer<typeof DatasetBuildSpecificationSchema>;\nexport type GeneratedTaskFile = z.infer<typeof GeneratedTaskFileSchema>;\nexport type TrainingPathRecommendation = z.infer<typeof TrainingPathRecommendationSchema>;\nexport type TrainingMethodReadinessReasonCode = z.infer<typeof TrainingMethodReadinessReasonCodeSchema>;\nexport type TrainingMethodReadiness = z.infer<typeof TrainingMethodReadinessSchema>;\nexport type TasksetReadinessReport = z.infer<typeof TasksetReadinessReportSchema>;\nexport type AuthoringProvenance = z.infer<typeof AuthoringProvenanceSchema>;\nexport type AuthoringRepair = z.infer<typeof AuthoringRepairSchema>;\nexport type Taskset = z.infer<typeof TasksetSchema>;\n\nexport function isTrainingSourceRef(\n source: TasksetSourceRef,\n): source is TrainingSourceRef {\n return source.schemaVersion === \"openpond.trainingSource.v1\";\n}\n","import { TasksetDraftSchema, type TasksetDraft } from \"./taskset-draft-document.js\";\n\nexport type TasksetDraftPublishIssue = {\n code: string;\n message: string;\n path: string | null;\n};\n\nexport class TasksetDraftPublishError extends Error {\n readonly issues: TasksetDraftPublishIssue[];\n\n constructor(issues: TasksetDraftPublishIssue[]) {\n super(issues.map((issue) => issue.message).join(\"\\n\"));\n this.name = \"TasksetDraftPublishError\";\n this.issues = issues;\n }\n}\n\nexport function createTasksetDraft(input: {\n profileId: string;\n modelScope?: TasksetDraft[\"modelScope\"];\n id?: string;\n name?: string;\n now?: string;\n}): TasksetDraft {\n const timestamp = input.now ?? new Date().toISOString();\n const id = input.id?.trim() || `taskset-draft-${globalThis.crypto.randomUUID()}`;\n return TasksetDraftSchema.parse({\n schemaVersion: \"openpond.tasksetDraft.v1\",\n id,\n revision: 1,\n profileId: input.profileId,\n modelScope: input.modelScope ?? null,\n name: input.name?.trim() ?? \"\",\n objective: \"\",\n purpose: \"general\",\n benchmark: null,\n preferenceComparison: null,\n status: \"draft\",\n sourceRefs: [],\n datasetArtifact: null,\n policy: {\n policyVisibleFields: [\"input\"],\n privilegedFields: [\"expectedOutput\"],\n hiddenGraderRefs: [],\n connectedAppScopes: [],\n },\n environment: {\n protocolVersion: \"openpond.taskEnvironment.v1\",\n kind: \"chat\",\n entrypoint: \"openpond-chat-v1\",\n stateful: false,\n deterministicSeeds: true,\n toolNames: [],\n lifecycle: [\"create\", \"reset\", \"step\", \"grade\", \"cleanup\"],\n defaultTimeoutMs: 120_000,\n networkPolicy: \"none\",\n resources: [],\n metadata: {},\n },\n output: {\n mode: \"text\",\n jsonSchema: null,\n renderer: null,\n },\n capabilities: {\n schemaVersion: \"openpond.tasksetCapabilities.v1\",\n taskKind: \"chat\",\n supportedSignals: [\n \"demonstration\",\n \"preference\",\n \"correction\",\n \"feedback\",\n \"reward\",\n \"label\",\n ],\n compatibleMethods: [\"none\"],\n rewardKinds: [\"none\"],\n requiresTools: false,\n requiresState: false,\n requiresPrivilegedGrading: true,\n environmentPlacements: [\"local\", \"remote\", \"colocated\"],\n exportable: true,\n portabilityBlockers: [],\n },\n metrics: {\n schemaVersion: \"openpond.tasksetMetricPolicy.v1\",\n primaryMetric: \"score\",\n aggregation: \"mean_score\",\n missingReward: \"zero\",\n customAggregator: null,\n },\n review: {\n enabled: false,\n candidateCount: 2,\n minimumSamples: 100,\n allowTies: true,\n allowRejectAll: true,\n rubric: \"\",\n criteria: [],\n },\n tasks: [],\n graders: [],\n graderFixtures: [],\n learningSignals: {\n demonstrations: [],\n preferences: [],\n corrections: [],\n feedback: [],\n rewards: [],\n labels: [],\n },\n publishedTasksetRef: null,\n createdAt: timestamp,\n updatedAt: timestamp,\n metadata: {},\n });\n}\n\nexport function draftPublishIssues(draft: TasksetDraft): TasksetDraftPublishIssue[] {\n const issues: TasksetDraftPublishIssue[] = [];\n if (!draft.name.trim()) issues.push({ code: \"name_missing\", message: \"Name is required.\", path: \"name\" });\n if (!draft.objective.trim()) issues.push({ code: \"objective_missing\", message: \"Objective is required.\", path: \"objective\" });\n if (!draft.datasetArtifact && draft.tasks.length === 0) issues.push({ code: \"tasks_missing\", message: \"Add at least one task or Dataset artifact.\", path: \"tasks\" });\n const sourceIds = new Set(draft.sourceRefs.map((source) => source.id));\n for (const task of draft.tasks) {\n for (const sourceId of task.sourceRefs) {\n if (!sourceIds.has(sourceId)) issues.push({ code: \"task_source_missing\", message: `Task ${task.id} references missing source ${sourceId}.`, path: `tasks.${task.id}.sourceRefs` });\n }\n }\n return issues;\n}\n","import type { TasksetCapabilityManifest } from \"./taskset-draft-core.js\";\nimport {\n isTrainingSourceRef,\n TASKSET_WORK_TOOL_NAMES,\n TasksetSchema,\n type Taskset,\n} from \"./taskset-authored-contracts.js\";\nimport { contentHash } from \"@openpond/harness\";\n\nexport type TasksetValidationIssue = {\n code: string;\n severity: \"warning\" | \"error\";\n message: string;\n path: string | null;\n};\n\nexport type TasksetValidationReport = {\n valid: boolean;\n taskset: Taskset | null;\n computedHash: string | null;\n issues: TasksetValidationIssue[];\n};\n\nexport function validateTaskset(input: unknown, options: { allowUnscoredOnlineRewardBatch?: boolean; purpose?: \"publication\" | \"execution\" } = {}): TasksetValidationReport {\n const parsed = TasksetSchema.safeParse(input);\n if (!parsed.success) {\n return {\n valid: false,\n taskset: null,\n computedHash: null,\n issues: parsed.error.issues.map((issue) => ({\n code: \"schema_invalid\",\n severity: \"error\",\n message: issue.message,\n path: issue.path.join(\".\"),\n })),\n };\n }\n\n const taskset = parsed.data;\n const issues: TasksetValidationIssue[] = [];\n validateSourceConsent(taskset, issues);\n validateDatasetArtifact(taskset, issues);\n validateSplitIsolation(taskset, issues);\n validatePolicyBoundary(taskset, issues);\n validateGraders(taskset, issues);\n if (options.purpose !== \"publication\") {\n if (!taskset.graders.length) issues.push({ code: \"graders_required\", severity: \"error\", message: \"Scored execution requires at least one grader.\", path: \"graders\" });\n validateGraderFixtures(taskset, issues, options);\n }\n validateLearningSignals(taskset, issues);\n validateCapabilities(taskset.capabilities, issues, taskset);\n validateWorkExecution(taskset, issues);\n\n const computedHash = tasksetContentHash(taskset);\n if (taskset.contentHash !== computedHash) {\n issues.push({\n code: \"content_hash_mismatch\",\n severity: \"error\",\n message: `Taskset contentHash is ${taskset.contentHash}, expected ${computedHash}.`,\n path: \"contentHash\",\n });\n }\n\n return {\n valid: !issues.some((issue) => issue.severity === \"error\"),\n taskset,\n computedHash,\n issues,\n };\n}\n\nfunction validateGraderFixtures(taskset: Taskset, issues: TasksetValidationIssue[], options: { allowUnscoredOnlineRewardBatch?: boolean }): void {\n // The hosted learning boundary checks the sealed batch and executable Reward\n // before opting into fresh-rollout GRPO. Human-only review has no automated\n // grader to calibrate; every mixed/automated taskset retains fixture gates.\n const humanReviewOnly = taskset.graders.length > 0 && taskset.graders.every(grader => grader.kind === \"human\");\n if (!humanReviewOnly && !taskset.graderFixtures.length && !(options.allowUnscoredOnlineRewardBatch && taskset.metadata.trainingMethod === \"grpo\" && taskset.metadata.learning)) {\n issues.push({ code: \"grader_fixtures_required\", severity: \"error\", message: \"Taskset admission requires authored grader fixtures.\", path: \"graderFixtures\" });\n }\n const taskIds = new Set(taskset.tasks.map((task) => task.id));\n const required = new Set([\"positive\", \"negative\", \"boundary\", \"adversarial\", \"prompt_injection\", \"infrastructure_failure\"]);\n for (const fixture of taskset.graderFixtures) {\n if (!taskset.datasetArtifact && !taskIds.has(fixture.taskId)) issues.push({ code: \"grader_fixture_task_missing\", severity: \"warning\", message: `Fixture ${fixture.id} references a task outside this Taskset revision (${fixture.taskId}).`, path: `graderFixtures.${fixture.id}.taskId` });\n required.delete(fixture.label);\n if (fixture.label === \"infrastructure_failure\" && !fixture.infrastructureError) issues.push({ code: \"infrastructure_fixture_error_missing\", severity: \"error\", message: `Infrastructure fixture ${fixture.id} must declare an infrastructure error.`, path: `graderFixtures.${fixture.id}.infrastructureError` });\n }\n for (const label of humanReviewOnly ? [] : required) issues.push({ code: \"grader_fixture_missing\", severity: \"warning\", message: `Taskset does not include the optional ${label} grader calibration fixture.`, path: \"graderFixtures\" });\n}\n\nfunction validateDatasetArtifact(\n taskset: Taskset,\n issues: TasksetValidationIssue[],\n): void {\n const artifact = taskset.datasetArtifact;\n if (!artifact) return;\n if (\n artifact.tasksetId !== taskset.id\n || artifact.tasksetRevision !== taskset.revision\n ) {\n issues.push({\n code: \"dataset_artifact_taskset_mismatch\",\n severity: \"error\",\n message: \"Dataset artifact identity does not match its Taskset revision.\",\n path: \"datasetArtifact\",\n });\n }\n const splitTotal = Object.values(artifact.splitCounts)\n .reduce((total, count) => total + count, 0);\n const shardTotal = artifact.shards\n .reduce((total, shard) => total + shard.rowCount, 0);\n if (splitTotal !== artifact.rowCount || shardTotal !== artifact.rowCount) {\n issues.push({\n code: \"dataset_artifact_row_count_mismatch\",\n severity: \"error\",\n message: \"Dataset artifact row, split, and shard counts do not agree.\",\n path: \"datasetArtifact.rowCount\",\n });\n }\n const shardSplitCounts = new Map<string, number>();\n for (const shard of artifact.shards) {\n shardSplitCounts.set(\n shard.split,\n (shardSplitCounts.get(shard.split) ?? 0) + shard.rowCount,\n );\n }\n for (const [split, count] of Object.entries(artifact.splitCounts)) {\n if ((shardSplitCounts.get(split) ?? 0) !== count) {\n issues.push({\n code: \"dataset_artifact_split_count_mismatch\",\n severity: \"error\",\n message: `Dataset artifact ${split} shard counts do not match its manifest.`,\n path: `datasetArtifact.splitCounts.${split}`,\n });\n }\n }\n const { contentHash: _contentHash, ...hashable } = artifact;\n if (contentHash(hashable) !== artifact.contentHash) {\n issues.push({\n code: \"dataset_artifact_hash_mismatch\",\n severity: \"error\",\n message: \"Dataset artifact manifest content hash is invalid.\",\n path: \"datasetArtifact.contentHash\",\n });\n }\n}\n\nexport function computeTasksetHash(taskset: Omit<Taskset, \"contentHash\"> | Taskset): string {\n return tasksetContentHash(taskset);\n}\n\nfunction tasksetContentHash(taskset: Omit<Taskset, \"contentHash\"> | Taskset): string {\n const { contentHash: _contentHash, status: _status, readiness: _readiness, updatedAt: _updatedAt, ...source } = taskset as Taskset;\n return contentHash(source);\n}\n\nexport function validatePortability(capabilities: TasksetCapabilityManifest): TasksetValidationIssue[] {\n const issues: TasksetValidationIssue[] = [];\n validateCapabilities(capabilities, issues, null);\n return issues;\n}\n\nfunction validateSourceConsent(taskset: Taskset, issues: TasksetValidationIssue[]): void {\n for (const [index, source] of taskset.sourceRefs.entries()) {\n if (isTrainingSourceRef(source) && source.consent.status !== \"granted\") {\n issues.push({ code: \"source_consent_missing\", severity: \"error\", message: `Source ${source.id} is not consented.`, path: `sourceRefs.${index}.consent.status` });\n }\n if (source.secretScanStatus !== \"passed\") {\n issues.push({ code: \"source_secret_scan\", severity: \"error\", message: `Source ${source.id} did not pass secret scanning.`, path: `sourceRefs.${index}.secretScanStatus` });\n }\n if (source.piiScanStatus !== \"passed\") {\n issues.push({ code: \"source_pii_scan\", severity: \"error\", message: `Source ${source.id} has unresolved PII policy.`, path: `sourceRefs.${index}.piiScanStatus` });\n }\n if (source.licensingStatus !== \"approved\") {\n issues.push({ code: \"source_license\", severity: \"error\", message: `Source ${source.id} has unresolved licensing policy.`, path: `sourceRefs.${index}.licensingStatus` });\n }\n }\n}\n\nfunction validateSplitIsolation(taskset: Taskset, issues: TasksetValidationIssue[]): void {\n const clusterSplits = new Map<string, Set<string>>();\n for (const task of taskset.tasks) {\n const splits = clusterSplits.get(task.clusterKey) ?? new Set<string>();\n splits.add(task.split);\n clusterSplits.set(task.clusterKey, splits);\n }\n for (const [cluster, splits] of clusterSplits) {\n if (splits.size > 1) {\n issues.push({ code: \"split_cluster_contamination\", severity: \"error\", message: `Source cluster ${cluster} appears in multiple splits: ${[...splits].join(\", \")}.`, path: \"tasks\" });\n }\n }\n const frozenCount = taskset.datasetArtifact\n ? taskset.datasetArtifact.splitCounts.frozen_eval ?? 0\n : taskset.tasks.filter((task) => task.split === \"frozen_eval\").length;\n if (frozenCount === 0) issues.push({ code: \"frozen_eval_missing\", severity: \"warning\", message: \"Add an independent test example before training.\", path: \"tasks\" });\n}\n\nfunction validateWorkExecution(\n taskset: Taskset,\n issues: TasksetValidationIssue[],\n): void {\n if (taskset.environment.kind !== \"work\") return;\n if (taskset.environment.entrypoint !== \"openpond-work-v1\") {\n issues.push({\n code: \"work_entrypoint_invalid\",\n severity: \"error\",\n message: \"Work Tasksets must use the openpond-work-v1 entrypoint.\",\n path: \"environment.entrypoint\",\n });\n }\n if (!taskset.environment.lifecycle.includes(\"reset\") || !taskset.environment.lifecycle.includes(\"cleanup\")) {\n issues.push({\n code: \"work_reset_lifecycle_missing\",\n severity: \"error\",\n message: \"Work attempts require reset and cleanup; filesystem state belongs to one attempt.\",\n path: \"environment.lifecycle\",\n });\n }\n const allowedTools = new Set<string>(TASKSET_WORK_TOOL_NAMES);\n const unknownTools = taskset.environment.toolNames.filter(\n (name) => !allowedTools.has(name),\n );\n if (unknownTools.length) {\n issues.push({\n code: \"work_tool_unknown\",\n severity: \"error\",\n message: `Work Taskset declares unknown tools: ${unknownTools.join(\", \")}.`,\n path: \"environment.toolNames\",\n });\n }\n if (!taskset.environment.toolNames.includes(\"work_save_output\")) {\n issues.push({\n code: \"work_output_tool_missing\",\n severity: \"error\",\n message: \"Work Tasksets must declare work_save_output.\",\n path: \"environment.toolNames\",\n });\n }\n for (const lifecycle of [\"create\", \"reset\", \"step\", \"grade\", \"cleanup\"] as const) {\n if (!taskset.environment.lifecycle.includes(lifecycle)) {\n issues.push({\n code: \"work_lifecycle_incomplete\",\n severity: \"error\",\n message: `Work Tasksets require the ${lifecycle} lifecycle stage.`,\n path: \"environment.lifecycle\",\n });\n }\n }\n\n const sourceById = new Map(\n taskset.sourceRefs.map((source) => [source.id, source]),\n );\n for (const [taskIndex, task] of taskset.tasks.entries()) {\n const assetIds = new Set<string>();\n const fileNames = new Set<string>();\n for (const [assetIndex, asset] of (task.assets ?? []).entries()) {\n const path = `tasks.${taskIndex}.assets.${assetIndex}`;\n if (assetIds.has(asset.id)) {\n issues.push({\n code: \"work_asset_duplicate_id\",\n severity: \"error\",\n message: `Task ${task.id} repeats asset id ${asset.id}.`,\n path: `${path}.id`,\n });\n }\n const stagedPath = asset.stagingPath ?? asset.fileName;\n if (fileNames.has(stagedPath)) {\n issues.push({\n code: \"work_asset_duplicate_name\",\n severity: \"error\",\n message: `Task ${task.id} repeats staged path ${stagedPath}.`,\n path: `${path}.fileName`,\n });\n }\n assetIds.add(asset.id);\n fileNames.add(stagedPath);\n if (!task.sourceRefs.includes(asset.sourceRefId)) {\n issues.push({\n code: \"work_asset_task_source_missing\",\n severity: \"error\",\n message: `Asset ${asset.id} references source ${asset.sourceRefId} outside task ${task.id}.`,\n path: `${path}.sourceRefId`,\n });\n }\n const source = sourceById.get(asset.sourceRefId);\n if (!source) {\n issues.push({\n code: \"work_asset_source_missing\",\n severity: \"error\",\n message: `Asset ${asset.id} references missing source ${asset.sourceRefId}.`,\n path: `${path}.sourceRefId`,\n });\n } else if (\n \"sourceFileHashes\" in source\n && !source.sourceFileHashes?.includes(asset.sha256)\n ) {\n issues.push({\n code: \"work_asset_hash_unregistered\",\n severity: \"error\",\n message: `Asset ${asset.id} hash is not registered by source ${asset.sourceRefId}.`,\n path: `${path}.sha256`,\n });\n }\n if (\n source\n && \"kind\" in source\n && source.kind === \"uploaded_file\"\n && !source.originalFileNames.includes(asset.fileName)\n ) {\n issues.push({\n code: \"work_asset_name_unregistered\",\n severity: \"error\",\n message: `Asset ${asset.id} file name is not registered by source ${asset.sourceRefId}.`,\n path: `${path}.fileName`,\n });\n }\n if (\n source\n && \"kind\" in source\n && source.kind === \"uploaded_file\"\n && !source.mediaTypes.includes(asset.mediaType)\n ) {\n issues.push({\n code: \"work_asset_media_type_unregistered\",\n severity: \"error\",\n message: `Asset ${asset.id} media type is not registered by source ${asset.sourceRefId}.`,\n path: `${path}.mediaType`,\n });\n }\n if (asset.split !== task.split) {\n issues.push({\n code: \"work_asset_split_mismatch\",\n severity: \"error\",\n message: `Asset ${asset.id} is assigned to ${asset.split}, not task split ${task.split}.`,\n path: `${path}.split`,\n });\n }\n }\n\n const outputPaths = new Set<string>();\n for (const [outputIndex, output] of (task.requiredOutputs ?? []).entries()) {\n const normalized = output.path.replaceAll(\"\\\\\", \"/\");\n const path = `tasks.${taskIndex}.requiredOutputs.${outputIndex}.path`;\n if (outputPaths.has(normalized)) {\n issues.push({\n code: \"work_output_duplicate_path\",\n severity: \"error\",\n message: `Task ${task.id} repeats required output path ${normalized}.`,\n path,\n });\n }\n outputPaths.add(normalized);\n }\n if ((task.requiredOutputs ?? []).length === 0) {\n issues.push({\n code: \"work_output_missing\",\n severity: \"error\",\n message: `Work task ${task.id} must declare at least one required output.`,\n path: `tasks.${taskIndex}.requiredOutputs`,\n });\n }\n }\n}\n\nfunction validatePolicyBoundary(taskset: Taskset, issues: TasksetValidationIssue[]): void {\n const visible = new Set(taskset.policy.policyVisibleFields);\n for (const field of taskset.policy.privilegedFields) {\n if (visible.has(field)) issues.push({ code: \"privileged_field_visible\", severity: \"error\", message: `Field ${field} is both policy-visible and privileged.`, path: \"policy\" });\n }\n for (const task of taskset.tasks) {\n if (task.privilegedContextRef && Object.keys(task.policyVisibleContext).includes(task.privilegedContextRef)) {\n issues.push({ code: \"privileged_context_leak\", severity: \"error\", message: `Task ${task.id} exposes its privileged context reference.`, path: `tasks.${task.id}.policyVisibleContext` });\n }\n }\n}\n\nfunction validateGraders(taskset: Taskset, issues: TasksetValidationIssue[]): void {\n const taskIds = new Set(taskset.tasks.map(task => task.id));\n const ids = new Set<string>();\n for (const grader of taskset.graders) {\n if (grader.taskIds?.some(id => !taskIds.has(id))) issues.push({ code: \"grader_task_missing\", severity: \"error\", message: `Grader ${grader.id} refers to a task outside this Dataset.`, path: \"graders\" });\n if (ids.has(grader.id)) issues.push({ code: \"grader_duplicate\", severity: \"error\", message: `Duplicate grader id ${grader.id}.`, path: \"graders\" });\n ids.add(grader.id);\n if (grader.kind === \"model_judge\" && grader.rewardEligible && grader.calibrationStatus !== \"passed\") {\n issues.push({ code: \"judge_calibration_pending\", severity: \"warning\", message: `Model judge ${grader.id} is selected for reward without a passing advisory calibration report.`, path: `graders.${grader.id}` });\n }\n if (grader.kind === \"model_judge\" && grader.calibrationStatus === \"passed\" && typeof grader.metadata.calibrationEvidenceHash !== \"string\") {\n issues.push({ code: \"judge_calibration_evidence_missing\", severity: \"warning\", message: `Model judge ${grader.id} declares calibration without an OpenPond fixture evidence hash.`, path: `graders.${grader.id}.metadata.calibrationEvidenceHash` });\n }\n if (grader.kind === \"human\" && grader.rewardEligible) {\n issues.push({ code: \"human_online_reward\", severity: \"error\", message: `Human grader ${grader.id} cannot be an online optimizer reward.`, path: `graders.${grader.id}` });\n }\n }\n}\n\nfunction validateLearningSignals(taskset: Taskset, issues: TasksetValidationIssue[]): void {\n const taskIds = new Set(taskset.tasks.map((task) => task.id));\n const sourceIds = new Set(taskset.sourceRefs.map((source) => source.id));\n for (const signal of [\n ...taskset.learningSignals.demonstrations,\n ...taskset.learningSignals.preferences,\n ...taskset.learningSignals.corrections,\n ...taskset.learningSignals.feedback,\n ...taskset.learningSignals.rewards,\n ...taskset.learningSignals.labels,\n ]) {\n if (signal.taskId && !taskset.datasetArtifact && !taskIds.has(signal.taskId)) {\n issues.push({ code: \"learning_signal_task_missing\", severity: \"error\", message: `Signal ${signal.id} references missing task ${signal.taskId}.`, path: `learningSignals.${signal.kind}.${signal.id}.taskId` });\n }\n if (signal.sourceRefs.some((sourceId) => !sourceIds.has(sourceId))) {\n issues.push({ code: \"learning_signal_source_missing\", severity: \"error\", message: `Signal ${signal.id} references a source outside the Dataset.`, path: `learningSignals.${signal.kind}.${signal.id}.sourceRefs` });\n }\n }\n for (const preference of taskset.learningSignals.preferences) {\n if (preference.chosen.trim() === preference.rejected.trim()) {\n issues.push({ code: \"preference_pair_identical\", severity: \"error\", message: `Preference ${preference.id} has identical chosen and rejected responses.`, path: `learningSignals.preferences.${preference.id}` });\n }\n }\n for (const reward of taskset.learningSignals.rewards) {\n if (!reward.executable) {\n issues.push({ code: \"reward_not_executable\", severity: \"warning\", message: `Reward ${reward.id} is a reviewed specification but has no executable verifier yet.`, path: `learningSignals.rewards.${reward.id}.executable` });\n }\n }\n}\n\nfunction validateCapabilities(\n capabilities: TasksetCapabilityManifest,\n issues: TasksetValidationIssue[],\n taskset: Taskset | null,\n): void {\n if (!capabilities.exportable && capabilities.portabilityBlockers.length === 0) {\n issues.push({ code: \"portability_reason_missing\", severity: \"error\", message: \"Non-exportable Tasksets must declare a portability blocker.\", path: \"capabilities.portabilityBlockers\" });\n }\n if (capabilities.compatibleMethods.includes(\"grpo\") && !capabilities.rewardKinds.some((kind) => kind === \"exact\" || kind === \"deterministic\" || kind === \"model_judge\")) {\n issues.push({ code: \"grpo_reward_missing\", severity: \"error\", message: \"GRPO compatibility requires a scalar reward kind.\", path: \"capabilities.rewardKinds\" });\n }\n if (taskset?.capabilities.compatibleMethods.includes(\"sft\") && taskset.learningSignals.demonstrations.length === 0) {\n issues.push({ code: \"sft_demonstrations_missing\", severity: \"error\", message: \"SFT compatibility requires approved demonstrations.\", path: \"learningSignals.demonstrations\" });\n }\n if (taskset?.capabilities.compatibleMethods.includes(\"dpo\") && taskset.learningSignals.preferences.length === 0) {\n issues.push({ code: \"dpo_preferences_missing\", severity: \"error\", message: \"DPO compatibility requires chosen and rejected response pairs.\", path: \"learningSignals.preferences\" });\n }\n if (\n taskset\n && (taskset.capabilities.compatibleMethods.includes(\"grpo\") || taskset.capabilities.compatibleMethods.includes(\"ppo\"))\n && !taskset.learningSignals.rewards.some((reward) => reward.executable)\n && !taskset.graders.some(grader => grader.rewardEligible && grader.weight > 0 && grader.kind !== \"human\")\n ) {\n issues.push({ code: \"online_reward_not_executable\", severity: \"error\", message: \"GRPO/PPO compatibility requires an executable scalar reward.\", path: \"learningSignals.rewards\" });\n }\n}\n"],"mappings":"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","names":["z","TasksetMetricPolicySchema","IdSchema","z","TimestampSchema","HashSchema","MetadataSchema","TasksetMetricPolicySchema"]}

package/dist/chunk-HGXVOFCL.js.map DELETED Viewed

@@ -1 +0,0 @@

- {"version":3,"sources":["../src/model-projects.ts","../src/protocol.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { ModelInitialLearningSchema, type ModelInitialLearning } from \"./model-learning-intent.js\";\nexport { ModelInitialLearningSchema, type ModelInitialLearning } from \"./model-learning-intent.js\";\nimport { assertBoundedTaskJson } from \"@openpond/evals/task-schema\";\n\nimport {\n MODEL_PROJECT_API_RESPONSE_MAX_BYTES,\n MODEL_PROJECT_SYNC_MAX_BYTES,\n OPENPOND_MODEL_PROJECT_MEDIA_TYPE,\n OpenPondProtocolError,\n assertCanonicalPayloadSize,\n canonicalSha256,\n parseBoundedJson,\n} from \"./protocol.js\";\n\nexport {\n MODEL_PROJECT_API_RESPONSE_MAX_BYTES,\n MODEL_PROJECT_SYNC_MAX_BYTES,\n OPENPOND_MODEL_PROJECT_MEDIA_TYPE,\n} from \"./protocol.js\";\n\nconst IdSchema = z.string().trim().min(1).max(500);\nconst HashSchema = z.string().regex(/^[a-f0-9]{64}$/);\nconst TimestampSchema = z.string().datetime({ offset: true });\n\nexport const ModelProjectImmutableRefSchema = z\n .object({\n id: IdSchema,\n contentHash: HashSchema,\n })\n .strict();\n\nexport const ModelProjectVersionedRefSchema =\n ModelProjectImmutableRefSchema.extend({\n revision: z.number().int().positive(),\n }).strict();\n\nexport const ModelProjectBaseModelSchema = z\n .object({\n schemaVersion: z.literal(\"openpond.baseModelPreference.v1\"),\n modelId: IdSchema,\n revision: z.string().trim().min(1).max(256).nullable(),\n tokenizerRevision: z.string().trim().min(1).max(256).nullable(),\n chatTemplateHash: z.string().trim().min(8).max(256).nullable(),\n modelAssetId: IdSchema.nullable(),\n source: z.enum([\"managed\", \"local\", \"builtin\"]),\n })\n .strict();\n\nexport const ModelProjectTrainingMethodSchema = z.enum([\n \"sft\",\n \"dpo\",\n \"grpo\",\n \"ppo\",\n \"sdft\",\n \"opd\",\n \"opsd\",\n \"sdpo\",\n]);\n\n/**\n * A versioned recipe document stored while a Project is still mutable.\n * The training endpoint validates the selected recipe version in full before\n * accepting an immutable Job; Project sync preserves newer recipe fields.\n */\nexport const ModelProjectRecipeDocumentSchema = z\n .object({\n schemaVersion: z.string().regex(/^openpond\\.[A-Za-z0-9]+Recipe\\.v\\d+$/),\n method: ModelProjectTrainingMethodSchema,\n parameterization: z.enum([\"lora\", \"full\"]),\n })\n .catchall(z.unknown());\n\n/** The published Profile source selected for this Model's Harness. */\nexport const ModelProfileSourceSelectionSchema = z.object({\n profileProjectId: IdSchema,\n sourceRevision: z.string().regex(/^[a-f0-9]{40,64}$/),\n harnessRelease: ModelProjectImmutableRefSchema,\n}).strict();\n\n/** A held-out check selected from an exact released Profile catalog. Its\n * Taskset and grader stay in the evaluation runtime, outside training input. */\nexport const ModelProfileEvaluationSelectionSchema = z.object({\n profileProjectId: IdSchema,\n sourceRevision: z.string().regex(/^[a-f0-9]{40,64}$/),\n catalogHash: HashSchema,\n definitionId: IdSchema,\n harnessRelease: ModelProjectImmutableRefSchema,\n tasksetRelease: ModelProjectImmutableRefSchema,\n}).strict();\n\nexport const ModelProjectTrainingSetupSchema = z\n .object({\n tasksetRef: ModelProjectVersionedRefSchema.nullable().default(null),\n evaluationTasksetRef: ModelProjectVersionedRefSchema.nullable().optional(),\n profileSource: ModelProfileSourceSelectionSchema.nullable().optional(),\n profileEvaluation: ModelProfileEvaluationSelectionSchema.nullable().optional(),\n rewardBindingRef: ModelProjectVersionedRefSchema.nullable().optional(),\n tasksetRelease: ModelProjectImmutableRefSchema.nullable().default(null),\n harnessRelease: ModelProjectImmutableRefSchema.nullable().default(null),\n baseModel: ModelProjectBaseModelSchema.nullable().default(null),\n method: ModelProjectTrainingMethodSchema.nullable().default(null),\n destinationId: IdSchema.nullable().default(null),\n managedRolloutPlacement: z\n .enum([\"local\", \"remote\"])\n .default(\"remote\"),\n managedGpuPlacementObjective: z\n .enum([\"fast\", \"balanced\", \"economical\"])\n .default(\"balanced\"),\n managedGpuRequirement: z\n .enum([\"any\", \"h100_hbm3\"])\n .default(\"any\"),\n runPreset: z\n .enum([\"small\", \"standard\", \"custom\", \"small_experiment\"])\n .nullable()\n .default(null),\n recipe: ModelProjectRecipeDocumentSchema.nullable().default(null),\n preferredMaximumSpendUsd: z.number().nonnegative().nullable().default(null),\n preferredRetentionDays: z\n .number()\n .int()\n .nonnegative()\n .nullable()\n .default(null),\n })\n .strict();\n\nexport const HostedModelProjectTrainingSetupSchema =\n ModelProjectTrainingSetupSchema.omit({ managedGpuRequirement: true });\n\nexport const HostedModelProjectLinkSchema = z\n .object({\n schemaVersion: z.literal(\"openpond.hostedModelProjectLink.v1\"),\n apiOrigin: z.string().url().refine(value => new URL(value).origin === value, \"Use a canonical API origin.\").nullable().default(null),\n teamId: IdSchema,\n projectId: IdSchema,\n portableProjectId: IdSchema,\n revision: z.number().int().positive(),\n etag: HashSchema,\n syncedSourceRevision: z.number().int().positive(),\n syncedAt: TimestampSchema,\n tasksets: z\n .array(\n z\n .object({\n localTasksetId: IdSchema,\n localTasksetHash: HashSchema.nullable().default(null),\n releaseId: IdSchema,\n releaseRevision: z.number().int().positive(),\n releaseHash: HashSchema,\n packageHash: HashSchema.nullable().default(null),\n hostedTasksetId: IdSchema,\n syncedAt: TimestampSchema,\n })\n .strict(),\n )\n .max(10_000)\n .default([]),\n })\n .strict();\n\nexport const ModelProjectTasksetSyncSchema = z\n .object({\n localTasksetId: IdSchema,\n releaseId: IdSchema,\n releaseRevision: z.number().int().positive(),\n releaseHash: HashSchema,\n state: z.enum([\"syncing\", \"synced\", \"sync_failed\"]),\n hostedTasksetId: IdSchema.nullable().default(null),\n lastAttemptAt: TimestampSchema,\n syncedAt: TimestampSchema.nullable().default(null),\n lastError: z.string().trim().min(1).max(5_000).nullable().default(null),\n })\n .strict();\n\nexport const ModelProjectSchema = z\n .object({\n schemaVersion: z.literal(\"openpond.modelProject.v2\"),\n id: IdSchema,\n profileId: IdSchema,\n revision: z.number().int().positive().default(1),\n name: z.string().trim().min(1).max(200),\n objective: z.string().trim().max(5_000).nullable(),\n defaultBaseModel: ModelProjectBaseModelSchema.nullable(),\n defaultDestinationId: IdSchema.nullable(),\n trainingSetup: ModelProjectTrainingSetupSchema,\n hosted: HostedModelProjectLinkSchema.nullable().default(null),\n tasksetSyncs: z\n .array(ModelProjectTasksetSyncSchema)\n .max(10_000)\n .default([]),\n createdAt: TimestampSchema,\n updatedAt: TimestampSchema,\n })\n .strict();\n\n/** User-editable configuration. Execution and hosting receipts are server-owned. */\nexport const ModelProjectEditableSchema = ModelProjectSchema.pick({\n id: true,\n profileId: true,\n name: true,\n objective: true,\n defaultBaseModel: true,\n defaultDestinationId: true,\n trainingSetup: true,\n});\n\n/** Zero creates a new Model; a positive revision updates that exact revision. */\nexport const ModelProjectSaveRequestSchema = z.object({\n schemaVersion: z.literal(\"openpond.modelProjectSave.v1\"),\n operationId: IdSchema,\n expectedRevision: z.number().int().nonnegative(),\n project: ModelProjectEditableSchema,\n learning: ModelInitialLearningSchema.optional(),\n}).strict().superRefine((value, context) => {\n if (value.learning && value.expectedRevision !== 0) context.addIssue({ code: \"custom\", path: [\"learning\"], message: \"Use learning settings to edit an existing Model's policy.\" });\n});\n\nexport type ModelProjectSaveRequest = z.infer<typeof ModelProjectSaveRequestSchema>;\n\n/** A read-only configuration check; it does not establish training or grader quality. */\nexport const ModelProjectConfigurationCheckSchema = z.object({\n schemaVersion: z.literal(\"openpond.modelProjectConfigurationCheck.v1\"),\n configurationHash: HashSchema,\n projectId: IdSchema,\n expectedRevision: z.number().int().nonnegative(),\n checkedAt: TimestampSchema,\n canSave: z.boolean(),\n deferred: z.array(z.enum([\"base_model\", \"taskset\"])).max(2),\n findings: z.array(z.object({\n code: IdSchema,\n severity: z.enum([\"error\", \"warning\"]),\n message: z.string().min(1).max(5000),\n field: z.string().min(1).max(500).nullable(),\n }).strict()).max(100),\n}).strict();\n\nexport type ModelProjectConfigurationCheck = z.infer<typeof ModelProjectConfigurationCheckSchema>;\n\nexport const ModelProjectBaseModelCandidateSchema = z.object({\n id: IdSchema, name: z.string().min(1).max(500), available: z.boolean(), preference: ModelProjectBaseModelSchema,\n}).strict();\n\nexport async function modelProjectConfigurationHash(request: ModelProjectSaveRequest): Promise<string> {\n const parsed = parseModelProjectSaveRequest(request);\n return canonicalSha256({ project: parsed.project, expectedRevision: parsed.expectedRevision, ...(parsed.learning ? { learning: parsed.learning } : {}) });\n}\n\nexport function parseModelProjectSaveRequest(value: unknown): ModelProjectSaveRequest {\n try {\n assertBoundedTaskJson(value, MODEL_PROJECT_SYNC_MAX_BYTES);\n } catch {\n throw new OpenPondModelProjectApiError(400, {\n schemaVersion: \"openpond.modelProjectApiError.v2\", code: \"model_configuration_json_invalid\",\n message: \"Model configuration must be bounded JSON data.\", retryable: false, requestId: null, details: {},\n });\n }\n return ModelProjectSaveRequestSchema.parse(value);\n}\n\n/** Stable across transport retries; excludes server-owned revision/timestamps. */\nexport async function createModelProjectSaveRequest(\n project: z.input<typeof ModelProjectEditableSchema>,\n expectedRevision: number,\n learning?: ModelInitialLearning,\n): Promise<ModelProjectSaveRequest> {\n assertBoundedTaskJson(project, MODEL_PROJECT_SYNC_MAX_BYTES);\n const editable = ModelProjectEditableSchema.parse(project);\n assertCanonicalPayloadSize(editable, MODEL_PROJECT_SYNC_MAX_BYTES, \"Model configuration\");\n const initialLearning = learning ? ModelInitialLearningSchema.parse(learning) : undefined;\n const hash = await canonicalSha256({ project: editable, expectedRevision, ...(initialLearning ? { learning: initialLearning } : {}) });\n return parseModelProjectSaveRequest({\n schemaVersion: \"openpond.modelProjectSave.v1\",\n operationId: `model-save:${hash}`,\n expectedRevision,\n project: editable,\n ...(initialLearning ? { learning: initialLearning } : {}),\n });\n}\n\nexport const HostedModelProjectSyncSchema = z\n .object({\n schemaVersion: z.literal(\"openpond.hostedModelProjectSync.v2\"),\n portableProjectId: IdSchema,\n name: z.string().trim().min(1).max(200),\n objective: z.string().trim().max(5_000).nullable(),\n defaultBaseModel: ModelProjectBaseModelSchema.nullable(),\n defaultDestinationId: IdSchema.nullable(),\n trainingSetup: HostedModelProjectTrainingSetupSchema,\n sourceRevision: z.number().int().positive(),\n sourceUpdatedAt: TimestampSchema,\n expectedEtag: HashSchema.nullable().default(null),\n })\n .strict();\n\nexport const HostedModelProjectSummarySchema = z\n .object({\n id: IdSchema,\n teamId: IdSchema,\n portableProjectId: IdSchema,\n name: z.string().trim().min(1).max(200),\n objective: z.string().trim().max(5_000).nullable(),\n defaultBaseModel: ModelProjectBaseModelSchema.nullable(),\n defaultDestinationId: IdSchema.nullable(),\n trainingSetup: HostedModelProjectTrainingSetupSchema,\n sourceRevision: z.number().int().positive(),\n sourceUpdatedAt: TimestampSchema,\n revision: z.number().int().positive(),\n etag: HashSchema,\n createdAt: TimestampSchema,\n updatedAt: TimestampSchema,\n })\n .strict();\n\nexport const ModelProjectResourceSummarySchema = z\n .object({\n kind: z.enum([\n \"taskset_release\",\n \"harness_release\",\n \"dataset_release\",\n \"evidence_set\",\n \"model_version\",\n \"reward_model_version\",\n \"evaluation_receipt\",\n ]),\n ref: ModelProjectImmutableRefSchema,\n role: z.string().trim().min(1).max(200).nullable().default(null),\n updatedAt: TimestampSchema,\n })\n .strict();\n\nexport const HostedModelProjectDetailSchema = z\n .object({\n project: HostedModelProjectSummarySchema,\n resources: z.array(ModelProjectResourceSummarySchema).max(10_000),\n jobCount: z.number().int().nonnegative(),\n latestJobIds: z.array(IdSchema).max(100),\n })\n .strict();\n\nexport const ModelProjectApiErrorSchema = z\n .object({\n schemaVersion: z.literal(\"openpond.modelProjectApiError.v2\"),\n code: z.string().trim().min(1).max(200),\n message: z.string().trim().min(1).max(5_000),\n retryable: z.boolean().default(false),\n requestId: z.string().trim().min(1).max(500).nullable().default(null),\n details: z.record(z.string(), z.unknown()).default({}),\n })\n .strict();\n\nexport class OpenPondModelProjectApiError extends Error {\n readonly status: number;\n readonly code: string;\n readonly retryable: boolean;\n readonly requestId: string | null;\n readonly details: Record<string, unknown>;\n\n constructor(status: number, error: z.infer<typeof ModelProjectApiErrorSchema>) {\n super(error.message);\n this.name = \"OpenPondModelProjectApiError\";\n this.status = status;\n this.code = error.code;\n this.retryable = error.retryable;\n this.requestId = error.requestId;\n this.details = error.details;\n }\n}\n\nexport type ModelProject = z.infer<typeof ModelProjectSchema>;\nexport type ModelProjectTrainingSetup = z.infer<\n typeof ModelProjectTrainingSetupSchema\n>;\nexport type HostedModelProjectSync = z.infer<\n typeof HostedModelProjectSyncSchema\n>;\nexport type HostedModelProjectSummary = z.infer<\n typeof HostedModelProjectSummarySchema\n>;\nexport type HostedModelProjectDetail = z.infer<\n typeof HostedModelProjectDetailSchema\n>;\n\ntype ModelProjectsFetch = typeof fetch;\n\nfunction headersRecord(headers: HeadersInit | undefined): Record<string, string> {\n const result: Record<string, string> = {};\n new Headers(headers).forEach((value, key) => {\n result[key] = value;\n });\n return result;\n}\n\nexport function createModelProjectsClient(input: {\n baseUrl: string;\n fetch?: ModelProjectsFetch;\n headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);\n}) {\n const fetchImpl = input.fetch ?? fetch;\n const baseUrl = input.baseUrl.replace(/\\/$/, \"\");\n\n async function request(pathname: string, init?: RequestInit): Promise<unknown> {\n const configuredHeaders =\n typeof input.headers === \"function\"\n ? await input.headers()\n : (input.headers ?? {});\n const response = await fetchImpl(`${baseUrl}${pathname}`, {\n ...init,\n headers: {\n accept: OPENPOND_MODEL_PROJECT_MEDIA_TYPE,\n ...(init?.body\n ? { \"content-type\": OPENPOND_MODEL_PROJECT_MEDIA_TYPE }\n : {}),\n ...headersRecord(configuredHeaders),\n ...headersRecord(init?.headers),\n },\n });\n const body = parseBoundedJson(\n await response.text(),\n MODEL_PROJECT_API_RESPONSE_MAX_BYTES,\n \"Model Project API response\",\n );\n if (!response.ok) {\n const parsed = ModelProjectApiErrorSchema.safeParse(body);\n if (parsed.success) {\n throw new OpenPondModelProjectApiError(response.status, parsed.data);\n }\n throw new OpenPondProtocolError(\n \"invalid_error_response\",\n `Model Project request failed with HTTP ${response.status} and an invalid error envelope.`,\n );\n }\n return body;\n }\n\n return {\n async configurationCandidates() {\n return z.object({ candidates: z.array(ModelProjectBaseModelCandidateSchema).max(1000) }).strict().parse(\n await request(\"/v1/model-projects/configuration/candidates\", { headers: { accept: \"application/json\" } }),\n ).candidates;\n },\n async checkConfiguration(value: ModelProjectSaveRequest) {\n const parsed = parseModelProjectSaveRequest(value);\n return ModelProjectConfigurationCheckSchema.parse(await request(\"/v1/model-projects/configuration/check\", {\n method: \"POST\", headers: { accept: \"application/json\", \"content-type\": \"application/json\" }, body: JSON.stringify(parsed),\n }));\n },\n async saveConfiguration(value: ModelProjectSaveRequest) {\n const parsed = parseModelProjectSaveRequest(value);\n return HostedModelProjectSummarySchema.parse(await request(\"/v1/model-projects/configuration/save\", {\n method: \"POST\", headers: { accept: \"application/json\", \"content-type\": \"application/json\" }, body: JSON.stringify(parsed),\n }));\n },\n async upsert(project: HostedModelProjectSync) {\n assertCanonicalPayloadSize(\n project,\n MODEL_PROJECT_SYNC_MAX_BYTES,\n \"Model Project sync\",\n );\n const parsed = HostedModelProjectSyncSchema.parse(project);\n const body = await request(\n `/v1/model-projects/${encodeURIComponent(parsed.portableProjectId)}`,\n { method: \"PUT\", body: JSON.stringify(parsed) },\n );\n return HostedModelProjectSummarySchema.parse(\n unwrapObject(body, \"project\"),\n );\n },\n async list() {\n const body = await request(\"/v1/model-projects\");\n return z\n .array(HostedModelProjectSummarySchema)\n .parse(unwrapObject(body, \"projects\"));\n },\n async get(projectId: string) {\n const body = await request(\n `/v1/model-projects/${encodeURIComponent(IdSchema.parse(projectId))}`,\n );\n return HostedModelProjectDetailSchema.parse(body);\n },\n };\n}\n\nfunction unwrapObject(value: unknown, key: string): unknown {\n if (!value || typeof value !== \"object\" || Array.isArray(value)) return value;\n return key in value ? (value as Record<string, unknown>)[key] : value;\n}\n","export type CanonicalJsonValue =\n | null\n | boolean\n | number\n | string\n | CanonicalJsonValue[]\n | { [key: string]: CanonicalJsonValue };\n\nexport const OPENPOND_TRAINING_PROTOCOL_MAJOR = 2 as const;\nexport const OPENPOND_TRAINING_MEDIA_TYPE =\n \"application/vnd.openpond.training+json;version=2\" as const;\nexport const OPENPOND_MODEL_PROJECT_MEDIA_TYPE =\n \"application/vnd.openpond.model-project+json;version=2\" as const;\n\nexport const TRAINING_JOB_SUBMISSION_MAX_BYTES = 1_048_576;\nexport const TRAINING_INPUT_ARTIFACT_MAX_BYTES = 67_108_864;\nexport const TRAINING_API_RESPONSE_MAX_BYTES = 8_388_608;\nexport const MODEL_PROJECT_SYNC_MAX_BYTES = 524_288;\nexport const MODEL_PROJECT_API_RESPONSE_MAX_BYTES = 8_388_608;\n\nexport class OpenPondProtocolError extends Error {\n readonly code: string;\n\n constructor(code: string, message: string) {\n super(message);\n this.name = \"OpenPondProtocolError\";\n this.code = code;\n }\n}\n\n/**\n * Deterministic JSON used for content-addressed OpenPond protocol objects.\n * Object keys are sorted by Unicode code point, arrays retain their authored\n * order, and non-JSON/non-finite values are rejected rather than coerced.\n */\nexport function canonicalJson(value: unknown): string {\n return JSON.stringify(normalizeCanonicalJson(value));\n}\n\nexport function canonicalJsonByteLength(value: unknown): number {\n return new TextEncoder().encode(canonicalJson(value)).byteLength;\n}\n\nexport async function canonicalSha256(value: unknown): Promise<string> {\n const bytes = new TextEncoder().encode(canonicalJson(value));\n const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", bytes);\n return Array.from(new Uint8Array(digest), (byte) =>\n byte.toString(16).padStart(2, \"0\"),\n ).join(\"\");\n}\n\nexport function assertCanonicalPayloadSize(\n value: unknown,\n maximumBytes: number,\n label: string,\n): void {\n const actualBytes = canonicalJsonByteLength(value);\n if (actualBytes > maximumBytes) {\n throw new OpenPondProtocolError(\n \"payload_too_large\",\n `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`,\n );\n }\n}\n\nexport function parseBoundedJson(\n text: string,\n maximumBytes: number,\n label: string,\n): unknown {\n const actualBytes = new TextEncoder().encode(text).byteLength;\n if (actualBytes > maximumBytes) {\n throw new OpenPondProtocolError(\n \"response_too_large\",\n `${label} is ${actualBytes} bytes; the maximum is ${maximumBytes} bytes.`,\n );\n }\n try {\n return JSON.parse(text) as unknown;\n } catch {\n throw new OpenPondProtocolError(\n \"invalid_json\",\n `${label} was not valid JSON.`,\n );\n }\n}\n\nfunction normalizeCanonicalJson(value: unknown): CanonicalJsonValue {\n if (\n value === null ||\n typeof value === \"string\" ||\n typeof value === \"boolean\"\n ) {\n return value;\n }\n if (typeof value === \"number\") {\n if (!Number.isFinite(value)) {\n throw new OpenPondProtocolError(\n \"non_json_value\",\n \"Canonical JSON cannot contain a non-finite number.\",\n );\n }\n return Object.is(value, -0) ? 0 : value;\n }\n if (Array.isArray(value)) {\n return value.map((entry) => normalizeCanonicalJson(entry));\n }\n if (typeof value === \"object\") {\n const prototype = Object.getPrototypeOf(value);\n if (prototype !== Object.prototype && prototype !== null) {\n throw new OpenPondProtocolError(\n \"non_json_value\",\n \"Canonical JSON accepts only plain objects.\",\n );\n }\n const result: Record<string, CanonicalJsonValue> = {};\n for (const key of Object.keys(value as Record<string, unknown>).sort()) {\n const entry = (value as Record<string, unknown>)[key];\n if (entry === undefined || typeof entry === \"function\" || typeof entry === \"symbol\") {\n throw new OpenPondProtocolError(\n \"non_json_value\",\n `Canonical JSON cannot contain ${typeof entry} at ${key}.`,\n );\n }\n result[key] = normalizeCanonicalJson(entry);\n }\n return result;\n }\n throw new OpenPondProtocolError(\n \"non_json_value\",\n `Canonical JSON cannot contain ${typeof value}.`,\n );\n}\n"],"mappings":"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","names":[]}