openpond-sdk 0.3.3 → 0.4.0

package/dist/chunk-65D4C7HP.js

@@ -0,0 +1,273 @@
+import {
+  ModelProjectVersionedRefSchema,
+  canonicalJson
+} from "./chunk-5PRP457R.js";
+
+// src/model-starter-execution.ts
+import { z } from "zod";
+import { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from "@openpond/evals";
+import { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from "@openpond/evals/javascript-environment";
+import { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset } from "@openpond/evals/learning";
+import { assertBoundedTaskJson } from "@openpond/evals/task-schema";
+var HashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var ModelStarterEnvironmentAttemptSchema = z.object({
+  schemaVersion: z.literal("openpond.javascriptEnvironmentAttempt.v1"),
+  taskId: z.string(),
+  status: z.enum(["completed", "budget_exhausted", "cancelled", "timed_out", "policy_failure", "environment_failure"]),
+  output: z.string().nullable(),
+  collected: z.boolean(),
+  environmentCleanupComplete: z.boolean(),
+  snapshot: z.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema, seed: z.number().int(), initialStateHash: HashSchema, finalStateHash: HashSchema, state: z.record(z.string(), z.unknown()), events: z.array(z.record(z.string(), z.unknown())) }).strict().nullable(),
+  messages: z.array(z.unknown()),
+  error: z.string().nullable(),
+  contentHash: HashSchema
+}).strict();
+function verifyModelStarterEnvironmentAttempt(value, context) {
+  assertBoundedTaskJson(value, 16777216);
+  const result = ModelStarterEnvironmentAttemptSchema.parse(value);
+  const { contentHash, ...content } = result;
+  if (sealLearningContent(content).contentHash !== contentHash || result.taskId !== context.taskId || result.snapshot && (!equal(result.snapshot.definition, context.javascript) || result.snapshot.inputHash !== sealLearningContent(context.input).contentHash || result.snapshot.seed !== context.seed || result.snapshot.finalStateHash !== sealLearningContent(result.snapshot.state).contentHash)) throw new Error("Starter environment attempt differs from its admitted task or recorded bytes.");
+  return result;
+}
+var ModelStarterExecutionSchema = z.object({
+  environment: EnvironmentReleaseSchema,
+  verifierSet: VerifierSetReleaseSchema,
+  javascript: JavaScriptEnvironmentDefinitionSchema
+}).strict();
+var ModelStarterToolFixtureScriptSchema = z.object({
+  actions: z.array(z.object({ name: z.string().min(1).max(64), arguments: z.record(z.string(), z.unknown()) }).strict()).max(1e3)
+}).strict();
+function modelStarterExecutionAssetId(context) {
+  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Starter execution release references are missing.");
+  return `starter-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
+}
+function createModelStarterExecutionAsset(value) {
+  const execution = ModelStarterExecutionSchema.parse(value);
+  assertExecutionIntegrity(execution);
+  const id = modelStarterExecutionAssetId({ environmentRelease: { id: execution.environment.id, contentHash: execution.environment.contentHash }, verifierSetRelease: { id: execution.verifierSet.id, contentHash: execution.verifierSet.contentHash } });
+  const generated = createLearningTextAsset({ text: canonicalJson(execution), path: "environment/execution.json", mediaType: "application/json", visibility: "host_private" });
+  const { contentHash: _hash, ...content } = generated;
+  return sealLearningContent({ ...content, id, asset: { ...content.asset, id } });
+}
+function resolveModelStarterExecutionAsset(context, asset, assets) {
+  if (asset.id !== modelStarterExecutionAssetId(context) || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") throw new Error("Starter execution asset differs from its Taskset references.");
+  const execution = ModelStarterExecutionSchema.parse(JSON.parse(verifyLearningTextAsset(asset, asset.asset)));
+  validateModelStarterExecution(execution, context, assets);
+  return execution;
+}
+function equal(left, right) {
+  return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;
+}
+function assertExecutionIntegrity(execution) {
+  assertJavaScriptEnvironmentDefinition(execution.javascript);
+  for (const resource of [execution.environment, execution.verifierSet]) {
+    const { contentHash, ...content } = resource;
+    if (sealLearningContent(content).contentHash !== contentHash) throw new Error(`Starter execution resource integrity failed: ${resource.id}.`);
+  }
+  if (!equal(execution.environment.metadata.javascriptEnvironment, learningRef(execution.javascript))) throw new Error("Starter execution resources differ from its declared task context.");
+}
+function validateModelStarterExecution(execution, taskset, assets) {
+  if (!execution) {
+    if (taskset.environment.entrypoint === "openpond.javascript-environment.v1") throw new Error("Starter JavaScript execution resources are missing.");
+    return;
+  }
+  const { environment, verifierSet, javascript } = execution;
+  assertExecutionIntegrity(execution);
+  if (!equal(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) || !equal(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) || !equal(environment.contract, taskset.environment) || !equal(verifierSet.graders, taskset.graders) || !equal(taskset.tools, javascript.tools) || !equal(environment.metadata.javascriptEnvironment, learningRef(javascript))) {
+    throw new Error("Starter execution resources differ from its declared task context.");
+  }
+  const contract = environment.contract;
+  if (contract.entrypoint !== "openpond.javascript-environment.v1" || contract.kind !== "agent" || !contract.stateful || !contract.deterministicSeeds || contract.networkPolicy !== "none" || new Set(contract.lifecycle).size !== 5 || taskset.capabilities.length || taskset.policy.connectedAppScopes.length) {
+    throw new Error("Starter JavaScript environment declares unsupported host capabilities.");
+  }
+  for (const reference of [javascript.module, environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) {
+    if (!reference) continue;
+    const asset = assets.find((asset2) => asset2.id === reference.id);
+    if (!asset) throw new Error(`Starter environment asset is missing: ${reference.id}.`);
+    verifyLearningTextAsset(asset, reference);
+  }
+  for (const task of taskset.tasks) {
+    const asset = assets.find((asset2) => asset2.id === task.privilegedContextRef);
+    if (!asset || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") {
+      throw new Error(`Starter private initial state is missing: ${task.id}.`);
+    }
+    const state = JSON.parse(verifyLearningTextAsset(asset, asset.asset));
+    if (!state || typeof state !== "object" || Array.isArray(state)) throw new Error(`Starter initial state must be a JSON object: ${task.id}.`);
+    assertBoundedTaskJson(state, javascript.maxStateBytes);
+  }
+}
+
+// src/model-taskset-resources.ts
+import { z as z2 } from "zod";
+import { EnvironmentReleaseSchema as EnvironmentReleaseSchema2, VerifierSetReleaseSchema as VerifierSetReleaseSchema2, verifyEnvironmentRelease, verifyVerifierSetRelease } from "@openpond/evals";
+import { createLearningTextAsset as createLearningTextAsset2, sealLearningContent as sealLearningContent2, verifyLearningTextAsset as verifyLearningTextAsset2 } from "@openpond/evals/learning";
+var ModelTasksetExecutionResourcesSchema = z2.object({ environment: EnvironmentReleaseSchema2, verifierSet: VerifierSetReleaseSchema2 }).strict();
+function modelTasksetExecutionResourcesAssetId(context) {
+  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error("Taskset execution references are missing.");
+  return `taskset-execution-${sealLearningContent2({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;
+}
+function createModelTasksetExecutionResourcesAsset(value) {
+  const resources = ModelTasksetExecutionResourcesSchema.parse({ environment: value.environment, verifierSet: value.verifierSet });
+  assertIntegrity(resources);
+  const id = modelTasksetExecutionResourcesAssetId({ environmentRelease: { id: resources.environment.id, contentHash: resources.environment.contentHash }, verifierSetRelease: { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash } });
+  const { contentHash: _hash, ...asset } = createLearningTextAsset2({ text: canonicalJson(resources), path: "environment/resources.json", mediaType: "application/json", visibility: "host_private" });
+  return sealLearningContent2({ ...asset, id, asset: { ...asset.asset, id } });
+}
+function resolveModelTasksetExecutionResourcesAsset(context, asset) {
+  if (asset.id !== modelTasksetExecutionResourcesAssetId(context) || asset.asset.visibility !== "host_private" || asset.asset.mediaType !== "application/json") throw new Error("Taskset execution asset differs from its published references.");
+  const resources = ModelTasksetExecutionResourcesSchema.parse(JSON.parse(verifyLearningTextAsset2(asset, asset.asset)));
+  assertIntegrity(resources);
+  if (asset.id !== createModelTasksetExecutionResourcesAsset(resources).id || canonicalJson(context.environment) !== canonicalJson(resources.environment.contract) || canonicalJson(context.graders) !== canonicalJson(resources.verifierSet.graders)) throw new Error("Taskset differs from its execution resources.");
+  return resources;
+}
+function assertIntegrity(resources) {
+  if (!verifyEnvironmentRelease(resources.environment) || !verifyVerifierSetRelease(resources.verifierSet)) throw new Error("Taskset execution resource integrity failed.");
+}
+
+// src/model-taskset-derivation.ts
+import { z as z3 } from "zod";
+import { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease as verifyEnvironmentRelease2, verifyVerifierSetRelease as verifyVerifierSetRelease2 } from "@openpond/evals";
+import { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef as learningRef2, sameLearningRef, sealLearningContent as sealLearningContent3, verifyLearningTextAsset as verifyLearningTextAsset3 } from "@openpond/evals/learning";
+import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
+import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
+import { validateTaskValue } from "@openpond/evals/task-schema";
+var OwnerSchema = z3.object({ scopeId: z3.string().trim().min(1).max(500), modelId: z3.string().trim().min(1).max(500) }).strict();
+var ModelTasksetDerivationSchema = z3.object({
+  schemaVersion: z3.literal("openpond.modelTasksetDerivation.v1"),
+  owner: OwnerSchema,
+  root: ModelProjectVersionedRefSchema,
+  parent: ModelProjectVersionedRefSchema
+}).strict();
+var ModelTasksetPackageSchema = z3.object({
+  taskset: TasksetReleaseSchema,
+  taskDefinition: TaskDefinitionSchema,
+  rewardBinding: RewardBindingSchema,
+  rewards: z3.array(RewardReleaseSchema).min(1).max(100),
+  assets: z3.array(LearningTextAssetSchema).max(1e3),
+  executionResources: ModelTasksetExecutionResourcesSchema.optional(),
+  execution: ModelStarterExecutionSchema.optional()
+}).strict();
+var same = (left, right) => sealLearningContent3({ value: left }).contentHash === sealLearningContent3({ value: right }).contentHash;
+var identity = (owner, root) => `model-taskset-${sealLearningContent3({ owner, root }).contentHash}`;
+function deriveModelTaskset(input) {
+  const owner = OwnerSchema.parse(input.owner);
+  const source = validateModelTasksetPackage(input.source);
+  const previous = source.taskset.metadata.modelTasksetDerivation === void 0 ? null : ModelTasksetDerivationSchema.parse(source.taskset.metadata.modelTasksetDerivation);
+  if (previous && source.taskset.id !== identity(previous.owner, previous.root)) throw new Error("Derived Taskset identity differs from its ownership lineage.");
+  const owned = previous && same(previous.owner, owner);
+  const root = owned ? previous.root : learningRef2(source.taskset);
+  const id = owned ? source.taskset.id : identity(owner, root);
+  const revision = owned ? source.taskset.revision + 1 : 1;
+  const rewardBinding = RewardBindingSchema.parse(input.rewardBinding);
+  const rewards = input.rewards.map((reward) => RewardReleaseSchema.parse(reward));
+  const graders = compileBoundGraders(rewardBinding, rewards);
+  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
+  const policy = { ...source.taskset.policy, hiddenGraderRefs: graders.filter((grader) => grader.privileged).map((grader) => grader.id) };
+  const previousResources = source.executionResources ?? source.execution;
+  const environment = previousResources?.environment ?? createEnvironmentRelease({
+    schemaVersion: "openpond.environmentRelease.v1",
+    id: `${id}-environment`,
+    revision: 1,
+    contract: source.taskset.environment,
+    actionSchemaRef: null,
+    observationSchemaRef: null,
+    stateSchemaRef: null,
+    artifactCollection: { maxArtifacts: 1e5, maxTotalBytes: 25e7 },
+    adapterConformanceHashes: {},
+    metadata: {}
+  });
+  const verifierSet = createVerifierSetRelease({
+    schemaVersion: "openpond.verifierSetRelease.v1",
+    id: `${id}-verifiers`,
+    revision,
+    graders,
+    isolation: previousResources?.verifierSet.isolation ?? { processBoundary: "isolated_process", networkPolicy: "none", defaultTimeoutMs: Math.min(source.taskset.environment.defaultTimeoutMs, 3e5) },
+    calibrationReceiptRefs: [],
+    metadata: previousResources ? { sourceVerifierSet: learningRef2(previousResources.verifierSet) } : {}
+  });
+  const executionResources = { environment, verifierSet };
+  const execution = source.execution ? { ...source.execution, verifierSet } : void 0;
+  const { contentHash: _taskHash, ...taskContent } = source.taskset;
+  const { contentHash: _definitionHash, ...definitionContent } = source.taskDefinition;
+  const taskExecution = { ...definitionContent.execution, policy, environmentRelease: { id: environment.id, contentHash: environment.contentHash }, verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash } };
+  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent3({ ...definitionContent, id: `${id}-definition`, revision, rewardBinding: learningRef2(rewardBinding), execution: taskExecution }));
+  const authoring = source.taskset.metadata.starterAuthoring;
+  const graderFixtures = authoring && typeof authoring === "object" && !Array.isArray(authoring) && "graderFixtures" in authoring ? authoring.graderFixtures : void 0;
+  const taskset = TasksetReleaseSchema.parse(sealLearningContent3({
+    ...taskContent,
+    ...taskExecution,
+    id,
+    revision,
+    graders,
+    metadata: {
+      starter: { taskDefinition: learningRef2(taskDefinition), rewardBinding: learningRef2(rewardBinding) },
+      rewardExecution: { binding: rewardBinding, rewards },
+      ...graderFixtures === void 0 ? {} : { starterAuthoring: { graderFixtures } },
+      modelTasksetDerivation: { schemaVersion: "openpond.modelTasksetDerivation.v1", owner, root, parent: learningRef2(source.taskset) }
+    }
+  }));
+  return validateModelTasksetPackage({ taskset, taskDefinition, rewardBinding, rewards, assets: input.assets, executionResources, ...execution ? { execution } : {} });
+}
+function validateModelTasksetPackage(value) {
+  const result = ModelTasksetPackageSchema.parse(value);
+  const { taskset, taskDefinition, rewardBinding, rewards, assets, execution } = result;
+  for (const resource of [taskset, taskDefinition, rewardBinding, ...rewards, ...assets]) assertLearningContentHash(resource);
+  assertTasksetRelease(taskset);
+  if (rewardBinding.recipeRef) throw new Error("Resolve the Reward recipe into one standalone binding before deriving a Taskset.");
+  if (!sameLearningRef(taskDefinition.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset definition differs from its Reward binding.");
+  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
+  if (!same(taskDefinition.execution, { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} })) throw new Error("Taskset definition differs from its execution resources.");
+  if (!same(taskset.graders, compileBoundGraders(rewardBinding, rewards))) throw new Error("Taskset graders differ from its Reward binding.");
+  if (taskset.metadata.starter !== void 0) {
+    const metadata = z3.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);
+    if (!sameLearningRef(metadata.taskDefinition, learningRef2(taskDefinition)) || !sameLearningRef(metadata.rewardBinding, learningRef2(rewardBinding))) throw new Error("Taskset metadata differs from its immutable grading resources.");
+  }
+  if (taskset.metadata.rewardExecution !== void 0 && !same(taskset.metadata.rewardExecution, { binding: rewardBinding, rewards })) throw new Error("Taskset embedded Rewards differ from its immutable grading resources.");
+  if (taskset.metadata.rewardBinding !== void 0 && !sameLearningRef(ModelProjectVersionedRefSchema.parse(taskset.metadata.rewardBinding), learningRef2(rewardBinding))) throw new Error("Taskset Reward reference differs from its immutable grading resources.");
+  const resources = result.executionResources ?? execution;
+  if (taskset.environmentRelease && !resources) throw new Error("Deriving a Taskset requires its pinned execution resources.");
+  if (resources && (!verifyEnvironmentRelease2(resources.environment) || !verifyVerifierSetRelease2(resources.verifierSet) || !same(taskset.environmentRelease, { id: resources.environment.id, contentHash: resources.environment.contentHash }) || !same(taskset.verifierSetRelease, { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash }) || !same(taskset.environment, resources.environment.contract) || !same(taskset.graders, resources.verifierSet.graders))) throw new Error("Taskset differs from its pinned execution resources.");
+  validateModelStarterExecution(execution, taskset, assets);
+  if (new Set(assets.map((asset) => asset.id)).size !== assets.length) throw new Error("Taskset asset identities must be unique.");
+  for (const asset of assets) verifyLearningTextAsset3(asset, asset.asset);
+  for (const reference of resources ? [resources.environment.actionSchemaRef, resources.environment.observationSchemaRef, resources.environment.stateSchemaRef] : []) {
+    if (!reference) continue;
+    const asset = assets.find((asset2) => asset2.id === reference.id);
+    if (!asset) throw new Error(`Taskset environment asset is missing: ${reference.id}.`);
+    verifyLearningTextAsset3(asset, reference);
+  }
+  for (const task of taskset.tasks) {
+    if (task.policyVisibleContext.instructions !== taskDefinition.instructions || !validateTaskValue(taskDefinition.inputSchema, task.input).valid || task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Taskset task differs from its declared format: ${task.id}.`);
+    if (task.privilegedContextRef && !assets.some((asset) => asset.id === task.privilegedContextRef && asset.asset.visibility === "host_private")) throw new Error(`Taskset private context is missing: ${task.id}.`);
+  }
+  for (const reward of rewards) {
+    const implementation = reward.implementation;
+    const references = [...reward.assets, ..."verifierRef" in implementation ? [implementation.verifierRef] : [], ..."rubricRef" in implementation ? [implementation.rubricRef] : [], ..."inputContract" in implementation ? [implementation.inputContract] : []];
+    for (const reference of references) {
+      const asset = assets.find((asset2) => asset2.id === reference.id);
+      if (!asset || reference.visibility === "policy") throw new Error(`Taskset Reward requires its private asset: ${reference.id}.`);
+      verifyLearningTextAsset3(asset, reference);
+    }
+  }
+  return result;
+}
+
+export {
+  ModelStarterEnvironmentAttemptSchema,
+  verifyModelStarterEnvironmentAttempt,
+  ModelStarterExecutionSchema,
+  ModelStarterToolFixtureScriptSchema,
+  modelStarterExecutionAssetId,
+  createModelStarterExecutionAsset,
+  resolveModelStarterExecutionAsset,
+  validateModelStarterExecution,
+  ModelTasksetExecutionResourcesSchema,
+  modelTasksetExecutionResourcesAssetId,
+  createModelTasksetExecutionResourcesAsset,
+  resolveModelTasksetExecutionResourcesAsset,
+  ModelTasksetDerivationSchema,
+  ModelTasksetPackageSchema,
+  deriveModelTaskset,
+  validateModelTasksetPackage
+};
+//# sourceMappingURL=chunk-65D4C7HP.js.map

package/dist/chunk-65D4C7HP.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/model-starter-execution.ts", "../src/model-taskset-resources.ts", "../src/model-taskset-derivation.ts"],
+  "sourcesContent": ["import { z } from \"zod\";\nimport { EnvironmentReleaseSchema, VerifierSetReleaseSchema } from \"@openpond/evals\";\nimport { JavaScriptEnvironmentDefinitionSchema, assertJavaScriptEnvironmentDefinition } from \"@openpond/evals/javascript-environment\";\nimport { createLearningTextAsset, learningRef, sealLearningContent, verifyLearningTextAsset, type LearningTextAsset } from \"@openpond/evals/learning\";\nimport { assertBoundedTaskJson } from \"@openpond/evals/task-schema\";\nimport type { TasksetRelease } from \"@openpond/evals/tasksets\";\nimport { canonicalJson } from \"./protocol.js\";\nimport { ModelProjectVersionedRefSchema } from \"./model-projects.js\";\n\nconst HashSchema = z.string().regex(/^[a-f0-9]{64}$/);\nexport const ModelStarterEnvironmentAttemptSchema = z.object({\n  schemaVersion: z.literal(\"openpond.javascriptEnvironmentAttempt.v1\"), taskId: z.string(),\n  status: z.enum([\"completed\", \"budget_exhausted\", \"cancelled\", \"timed_out\", \"policy_failure\", \"environment_failure\"]),\n  output: z.string().nullable(), collected: z.boolean(), environmentCleanupComplete: z.boolean(),\n  snapshot: z.object({ definition: ModelProjectVersionedRefSchema, inputHash: HashSchema, seed: z.number().int(), initialStateHash: HashSchema, finalStateHash: HashSchema, state: z.record(z.string(), z.unknown()), events: z.array(z.record(z.string(), z.unknown())) }).strict().nullable(),\n  messages: z.array(z.unknown()), error: z.string().nullable(), contentHash: HashSchema,\n}).strict();\n\n/** Validate an owner-recorded runtime artifact against the admitted task.\n * Provenance/ownership of the artifact remains the execution host's concern. */\nexport function verifyModelStarterEnvironmentAttempt(value: unknown, context: { taskId: string; input: Record<string, unknown>; seed: number; javascript: z.infer<typeof ModelProjectVersionedRefSchema> }) {\n  assertBoundedTaskJson(value, 16_777_216);\n  const result = ModelStarterEnvironmentAttemptSchema.parse(value);\n  const { contentHash, ...content } = result;\n  if (sealLearningContent(content).contentHash !== contentHash || result.taskId !== context.taskId || (result.snapshot && (\n    !equal(result.snapshot.definition, context.javascript) || result.snapshot.inputHash !== sealLearningContent(context.input).contentHash || result.snapshot.seed !== context.seed || result.snapshot.finalStateHash !== sealLearningContent(result.snapshot.state).contentHash\n  ))) throw new Error(\"Starter environment attempt differs from its admitted task or recorded bytes.\");\n  return result;\n}\n\nexport const ModelStarterExecutionSchema = z.object({\n  environment: EnvironmentReleaseSchema,\n  verifierSet: VerifierSetReleaseSchema,\n  javascript: JavaScriptEnvironmentDefinitionSchema,\n}).strict();\nexport type ModelStarterExecution = z.infer<typeof ModelStarterExecutionSchema>;\nexport const ModelStarterToolFixtureScriptSchema = z.object({\n  actions: z.array(z.object({ name: z.string().min(1).max(64), arguments: z.record(z.string(), z.unknown()) }).strict()).max(1_000),\n}).strict();\nexport type ModelStarterExecutionContext = Pick<TasksetRelease, \"environment\" | \"environmentRelease\" | \"verifierSetRelease\" | \"tools\" | \"capabilities\" | \"policy\" | \"graders\" | \"tasks\">;\n\n/** Derivable from immutable Taskset refs, without putting private code in its metadata. */\nexport function modelStarterExecutionAssetId(context: Pick<ModelStarterExecutionContext, \"environmentRelease\" | \"verifierSetRelease\">): string {\n  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error(\"Starter execution release references are missing.\");\n  return `starter-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;\n}\n\n/** Persist alongside the package's private assets in the same creation transaction.\n * The existing authored-text resource bound also applies to this small closure. */\nexport function createModelStarterExecutionAsset(value: ModelStarterExecution): LearningTextAsset {\n  const execution = ModelStarterExecutionSchema.parse(value);\n  assertExecutionIntegrity(execution);\n  const id = modelStarterExecutionAssetId({ environmentRelease: { id: execution.environment.id, contentHash: execution.environment.contentHash }, verifierSetRelease: { id: execution.verifierSet.id, contentHash: execution.verifierSet.contentHash } });\n  const generated = createLearningTextAsset({ text: canonicalJson(execution), path: \"environment/execution.json\", mediaType: \"application/json\", visibility: \"host_private\" });\n  const { contentHash: _hash, ...content } = generated;\n  return sealLearningContent({ ...content, id, asset: { ...content.asset, id } });\n}\n\n/** The caller owns and verifies the Taskset manifest; this verifies its private\n * resource graph. Passing selected immutable task rows permits bounded hydration. */\nexport function resolveModelStarterExecutionAsset(context: ModelStarterExecutionContext, asset: LearningTextAsset, assets: LearningTextAsset[]): ModelStarterExecution {\n  if (asset.id !== modelStarterExecutionAssetId(context) || asset.asset.visibility !== \"host_private\" || asset.asset.mediaType !== \"application/json\") throw new Error(\"Starter execution asset differs from its Taskset references.\");\n  const execution = ModelStarterExecutionSchema.parse(JSON.parse(verifyLearningTextAsset(asset, asset.asset)));\n  validateModelStarterExecution(execution, context, assets);\n  return execution;\n}\n\nfunction equal(left: unknown, right: unknown): boolean {\n  return sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;\n}\n\nfunction assertExecutionIntegrity(execution: ModelStarterExecution): void {\n  assertJavaScriptEnvironmentDefinition(execution.javascript);\n  for (const resource of [execution.environment, execution.verifierSet]) {\n    const { contentHash, ...content } = resource;\n    if (sealLearningContent(content).contentHash !== contentHash) throw new Error(`Starter execution resource integrity failed: ${resource.id}.`);\n  }\n  if (!equal(execution.environment.metadata.javascriptEnvironment, learningRef(execution.javascript))) throw new Error(\"Starter execution resources differ from its declared task context.\");\n}\n\n/** Close executable dependencies before a host persists or runs a package. */\nexport function validateModelStarterExecution(\n  execution: ModelStarterExecution | undefined,\n  taskset: ModelStarterExecutionContext,\n  assets: LearningTextAsset[],\n): void {\n  if (!execution) {\n    if (taskset.environment.entrypoint === \"openpond.javascript-environment.v1\") throw new Error(\"Starter JavaScript execution resources are missing.\");\n    return;\n  }\n  const { environment, verifierSet, javascript } = execution;\n  assertExecutionIntegrity(execution);\n  if (!equal(taskset.environmentRelease, { id: environment.id, contentHash: environment.contentHash }) ||\n      !equal(taskset.verifierSetRelease, { id: verifierSet.id, contentHash: verifierSet.contentHash }) ||\n      !equal(environment.contract, taskset.environment) || !equal(verifierSet.graders, taskset.graders) ||\n      !equal(taskset.tools, javascript.tools) || !equal(environment.metadata.javascriptEnvironment, learningRef(javascript))) {\n    throw new Error(\"Starter execution resources differ from its declared task context.\");\n  }\n  const contract = environment.contract;\n  if (contract.entrypoint !== \"openpond.javascript-environment.v1\" || contract.kind !== \"agent\" ||\n      !contract.stateful || !contract.deterministicSeeds || contract.networkPolicy !== \"none\" ||\n      new Set(contract.lifecycle).size !== 5 || taskset.capabilities.length || taskset.policy.connectedAppScopes.length) {\n    throw new Error(\"Starter JavaScript environment declares unsupported host capabilities.\");\n  }\n  for (const reference of [javascript.module, environment.actionSchemaRef, environment.observationSchemaRef, environment.stateSchemaRef]) {\n    if (!reference) continue;\n    const asset = assets.find(asset => asset.id === reference.id);\n    if (!asset) throw new Error(`Starter environment asset is missing: ${reference.id}.`);\n    verifyLearningTextAsset(asset, reference);\n  }\n  for (const task of taskset.tasks) {\n    const asset = assets.find(asset => asset.id === task.privilegedContextRef);\n    if (!asset || asset.asset.visibility !== \"host_private\" || asset.asset.mediaType !== \"application/json\") {\n      throw new Error(`Starter private initial state is missing: ${task.id}.`);\n    }\n    const state: unknown = JSON.parse(verifyLearningTextAsset(asset, asset.asset));\n    if (!state || typeof state !== \"object\" || Array.isArray(state)) throw new Error(`Starter initial state must be a JSON object: ${task.id}.`);\n    assertBoundedTaskJson(state, javascript.maxStateBytes);\n  }\n}\n", "import { z } from \"zod\";\nimport { EnvironmentReleaseSchema, VerifierSetReleaseSchema, verifyEnvironmentRelease, verifyVerifierSetRelease } from \"@openpond/evals\";\nimport { createLearningTextAsset, sealLearningContent, verifyLearningTextAsset, type LearningTextAsset } from \"@openpond/evals/learning\";\nimport type { TasksetRelease } from \"@openpond/evals/tasksets\";\nimport { canonicalJson } from \"./protocol.js\";\n\nexport const ModelTasksetExecutionResourcesSchema = z.object({ environment: EnvironmentReleaseSchema, verifierSet: VerifierSetReleaseSchema }).strict();\ntype Resources = z.infer<typeof ModelTasksetExecutionResourcesSchema>;\ntype Context = Pick<TasksetRelease, \"environmentRelease\" | \"verifierSetRelease\" | \"environment\" | \"graders\">;\n\n/** Private resource identity follows the exact published execution references. */\nexport function modelTasksetExecutionResourcesAssetId(context: Pick<Context, \"environmentRelease\" | \"verifierSetRelease\">): string {\n  if (!context.environmentRelease || !context.verifierSetRelease) throw new Error(\"Taskset execution references are missing.\");\n  return `taskset-execution-${sealLearningContent({ environment: context.environmentRelease, verifiers: context.verifierSetRelease }).contentHash}`;\n}\n\nexport function createModelTasksetExecutionResourcesAsset(value: Resources): LearningTextAsset {\n  const resources = ModelTasksetExecutionResourcesSchema.parse({ environment: value.environment, verifierSet: value.verifierSet });\n  assertIntegrity(resources);\n  const id = modelTasksetExecutionResourcesAssetId({ environmentRelease: { id: resources.environment.id, contentHash: resources.environment.contentHash }, verifierSetRelease: { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash } });\n  const { contentHash: _hash, ...asset } = createLearningTextAsset({ text: canonicalJson(resources), path: \"environment/resources.json\", mediaType: \"application/json\", visibility: \"host_private\" });\n  return sealLearningContent({ ...asset, id, asset: { ...asset.asset, id } });\n}\n\n/** Resolve text or tool execution resources without trusting an asset's ID alone. */\nexport function resolveModelTasksetExecutionResourcesAsset(context: Context, asset: LearningTextAsset): Resources {\n  if (asset.id !== modelTasksetExecutionResourcesAssetId(context) || asset.asset.visibility !== \"host_private\" || asset.asset.mediaType !== \"application/json\") throw new Error(\"Taskset execution asset differs from its published references.\");\n  const resources = ModelTasksetExecutionResourcesSchema.parse(JSON.parse(verifyLearningTextAsset(asset, asset.asset)));\n  assertIntegrity(resources);\n  if (asset.id !== createModelTasksetExecutionResourcesAsset(resources).id || canonicalJson(context.environment) !== canonicalJson(resources.environment.contract) || canonicalJson(context.graders) !== canonicalJson(resources.verifierSet.graders)) throw new Error(\"Taskset differs from its execution resources.\");\n  return resources;\n}\n\nfunction assertIntegrity(resources: Resources): void {\n  if (!verifyEnvironmentRelease(resources.environment) || !verifyVerifierSetRelease(resources.verifierSet)) throw new Error(\"Taskset execution resource integrity failed.\");\n}\n", "import { z } from \"zod\";\nimport { createEnvironmentRelease, createVerifierSetRelease, verifyEnvironmentRelease, verifyVerifierSetRelease } from \"@openpond/evals\";\nimport { LearningTextAssetSchema, TaskDefinitionSchema, assertLearningContentHash, learningRef, sameLearningRef, sealLearningContent, verifyLearningTextAsset } from \"@openpond/evals/learning\";\nimport { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from \"@openpond/evals/rewards\";\nimport { TasksetReleaseSchema, assertTasksetRelease } from \"@openpond/evals/tasksets\";\nimport { validateTaskValue } from \"@openpond/evals/task-schema\";\n\nimport { ModelProjectVersionedRefSchema } from \"./model-projects.js\";\nimport { ModelStarterExecutionSchema, validateModelStarterExecution } from \"./model-starter-execution.js\";\nimport { ModelTasksetExecutionResourcesSchema } from \"./model-taskset-resources.js\";\n\nconst OwnerSchema = z.object({ scopeId: z.string().trim().min(1).max(500), modelId: z.string().trim().min(1).max(500) }).strict();\nexport const ModelTasksetDerivationSchema = z.object({\n  schemaVersion: z.literal(\"openpond.modelTasksetDerivation.v1\"),\n  owner: OwnerSchema,\n  root: ModelProjectVersionedRefSchema,\n  parent: ModelProjectVersionedRefSchema,\n}).strict();\n\n/** Immutable executable resources, independent of a catalog listing. */\nexport const ModelTasksetPackageSchema = z.object({\n  taskset: TasksetReleaseSchema,\n  taskDefinition: TaskDefinitionSchema,\n  rewardBinding: RewardBindingSchema,\n  rewards: z.array(RewardReleaseSchema).min(1).max(100),\n  assets: z.array(LearningTextAssetSchema).max(1_000),\n  executionResources: ModelTasksetExecutionResourcesSchema.optional(),\n  execution: ModelStarterExecutionSchema.optional(),\n}).strict();\nexport type ModelTasksetPackage = z.infer<typeof ModelTasksetPackageSchema>;\n\nconst same = (left: unknown, right: unknown) => sealLearningContent({ value: left }).contentHash === sealLearningContent({ value: right }).contentHash;\nconst identity = (owner: z.infer<typeof OwnerSchema>, root: z.infer<typeof ModelProjectVersionedRefSchema>) => `model-taskset-${sealLearningContent({ owner, root }).contentHash}`;\n\n/** Hosts authorize the source and owner, upload immutable files, then commit\n * this result together with the model CAS and operation receipt. This pure\n * compiler neither allocates a new identity on retry nor changes a consumer. */\nexport function deriveModelTaskset(input: {\n  owner: z.input<typeof OwnerSchema>;\n  source: ModelTasksetPackage;\n  rewardBinding: z.infer<typeof RewardBindingSchema>;\n  rewards: z.infer<typeof RewardReleaseSchema>[];\n  assets: z.infer<typeof LearningTextAssetSchema>[];\n}): ModelTasksetPackage {\n  const owner = OwnerSchema.parse(input.owner);\n  const source = validateModelTasksetPackage(input.source);\n  const previous = source.taskset.metadata.modelTasksetDerivation === undefined ? null : ModelTasksetDerivationSchema.parse(source.taskset.metadata.modelTasksetDerivation);\n  if (previous && source.taskset.id !== identity(previous.owner, previous.root)) throw new Error(\"Derived Taskset identity differs from its ownership lineage.\");\n  const owned = previous && same(previous.owner, owner);\n  const root = owned ? previous.root : learningRef(source.taskset);\n  const id = owned ? source.taskset.id : identity(owner, root);\n  const revision = owned ? source.taskset.revision + 1 : 1;\n  const rewardBinding = RewardBindingSchema.parse(input.rewardBinding);\n  const rewards = input.rewards.map(reward => RewardReleaseSchema.parse(reward));\n  const graders = compileBoundGraders(rewardBinding, rewards);\n  if (rewardBinding.recipeRef) throw new Error(\"Resolve the Reward recipe into one standalone binding before deriving a Taskset.\");\n  const policy = { ...source.taskset.policy, hiddenGraderRefs: graders.filter(grader => grader.privileged).map(grader => grader.id) };\n  const previousResources = source.executionResources ?? source.execution;\n  const environment = previousResources?.environment ?? createEnvironmentRelease({\n    schemaVersion: \"openpond.environmentRelease.v1\", id: `${id}-environment`, revision: 1,\n    contract: source.taskset.environment, actionSchemaRef: null, observationSchemaRef: null, stateSchemaRef: null,\n    artifactCollection: { maxArtifacts: 100_000, maxTotalBytes: 250_000_000 }, adapterConformanceHashes: {}, metadata: {},\n  });\n  const verifierSet = createVerifierSetRelease({\n    schemaVersion: \"openpond.verifierSetRelease.v1\", id: `${id}-verifiers`, revision, graders,\n    isolation: previousResources?.verifierSet.isolation ?? { processBoundary: \"isolated_process\", networkPolicy: \"none\", defaultTimeoutMs: Math.min(source.taskset.environment.defaultTimeoutMs, 300_000) },\n    calibrationReceiptRefs: [], metadata: previousResources ? { sourceVerifierSet: learningRef(previousResources.verifierSet) } : {},\n  });\n  const executionResources = { environment, verifierSet };\n  const execution = source.execution ? { ...source.execution, verifierSet } : undefined;\n  const { contentHash: _taskHash, ...taskContent } = source.taskset;\n  const { contentHash: _definitionHash, ...definitionContent } = source.taskDefinition;\n  const taskExecution = { ...definitionContent.execution, policy, environmentRelease: { id: environment.id, contentHash: environment.contentHash }, verifierSetRelease: { id: verifierSet.id, contentHash: verifierSet.contentHash } };\n  const taskDefinition = TaskDefinitionSchema.parse(sealLearningContent({ ...definitionContent, id: `${id}-definition`, revision, rewardBinding: learningRef(rewardBinding), execution: taskExecution }));\n  const authoring = source.taskset.metadata.starterAuthoring;\n  const graderFixtures = authoring && typeof authoring === \"object\" && !Array.isArray(authoring) && \"graderFixtures\" in authoring ? authoring.graderFixtures : undefined;\n  // Keep provenance through exact lineage. Source package qualifications and\n  // privacy attestations describe different bytes and must not be copied.\n  const taskset = TasksetReleaseSchema.parse(sealLearningContent({\n    ...taskContent, ...taskExecution, id, revision, graders,\n    metadata: {\n      starter: { taskDefinition: learningRef(taskDefinition), rewardBinding: learningRef(rewardBinding) },\n      rewardExecution: { binding: rewardBinding, rewards },\n      ...(graderFixtures === undefined ? {} : { starterAuthoring: { graderFixtures } }),\n      modelTasksetDerivation: { schemaVersion: \"openpond.modelTasksetDerivation.v1\", owner, root, parent: learningRef(source.taskset) },\n    },\n  }));\n  return validateModelTasksetPackage({ taskset, taskDefinition, rewardBinding, rewards, assets: input.assets, executionResources, ...(execution ? { execution } : {}) });\n}\n\nexport function validateModelTasksetPackage(value: unknown): ModelTasksetPackage {\n  const result = ModelTasksetPackageSchema.parse(value);\n  const { taskset, taskDefinition, rewardBinding, rewards, assets, execution } = result;\n  for (const resource of [taskset, taskDefinition, rewardBinding, ...rewards, ...assets]) assertLearningContentHash(resource);\n  assertTasksetRelease(taskset);\n  if (rewardBinding.recipeRef) throw new Error(\"Resolve the Reward recipe into one standalone binding before deriving a Taskset.\");\n  if (!sameLearningRef(taskDefinition.rewardBinding, learningRef(rewardBinding))) throw new Error(\"Taskset definition differs from its Reward binding.\");\n  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;\n  if (!same(taskDefinition.execution, { policy, environment, ...(environmentRelease ? { environmentRelease } : {}), tools, capabilities, ...(verifierSetRelease ? { verifierSetRelease } : {}) })) throw new Error(\"Taskset definition differs from its execution resources.\");\n  if (!same(taskset.graders, compileBoundGraders(rewardBinding, rewards))) throw new Error(\"Taskset graders differ from its Reward binding.\");\n  if (taskset.metadata.starter !== undefined) {\n    const metadata = z.object({ taskDefinition: ModelProjectVersionedRefSchema, rewardBinding: ModelProjectVersionedRefSchema }).passthrough().parse(taskset.metadata.starter);\n    if (!sameLearningRef(metadata.taskDefinition, learningRef(taskDefinition)) || !sameLearningRef(metadata.rewardBinding, learningRef(rewardBinding))) throw new Error(\"Taskset metadata differs from its immutable grading resources.\");\n  }\n  if (taskset.metadata.rewardExecution !== undefined && !same(taskset.metadata.rewardExecution, { binding: rewardBinding, rewards })) throw new Error(\"Taskset embedded Rewards differ from its immutable grading resources.\");\n  if (taskset.metadata.rewardBinding !== undefined && !sameLearningRef(ModelProjectVersionedRefSchema.parse(taskset.metadata.rewardBinding), learningRef(rewardBinding))) throw new Error(\"Taskset Reward reference differs from its immutable grading resources.\");\n  const resources = result.executionResources ?? execution;\n  if (taskset.environmentRelease && !resources) throw new Error(\"Deriving a Taskset requires its pinned execution resources.\");\n  if (resources && (!verifyEnvironmentRelease(resources.environment) || !verifyVerifierSetRelease(resources.verifierSet) ||\n      !same(taskset.environmentRelease, { id: resources.environment.id, contentHash: resources.environment.contentHash }) ||\n      !same(taskset.verifierSetRelease, { id: resources.verifierSet.id, contentHash: resources.verifierSet.contentHash }) ||\n      !same(taskset.environment, resources.environment.contract) || !same(taskset.graders, resources.verifierSet.graders))) throw new Error(\"Taskset differs from its pinned execution resources.\");\n  validateModelStarterExecution(execution, taskset, assets);\n  if (new Set(assets.map(asset => asset.id)).size !== assets.length) throw new Error(\"Taskset asset identities must be unique.\");\n  for (const asset of assets) verifyLearningTextAsset(asset, asset.asset);\n  for (const reference of resources ? [resources.environment.actionSchemaRef, resources.environment.observationSchemaRef, resources.environment.stateSchemaRef] : []) {\n    if (!reference) continue;\n    const asset = assets.find(asset => asset.id === reference.id);\n    if (!asset) throw new Error(`Taskset environment asset is missing: ${reference.id}.`);\n    verifyLearningTextAsset(asset, reference);\n  }\n  for (const task of taskset.tasks) {\n    if (task.policyVisibleContext.instructions !== taskDefinition.instructions || !validateTaskValue(taskDefinition.inputSchema, task.input).valid ||\n        (task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid)) throw new Error(`Taskset task differs from its declared format: ${task.id}.`);\n    if (task.privilegedContextRef && !assets.some(asset => asset.id === task.privilegedContextRef && asset.asset.visibility === \"host_private\")) throw new Error(`Taskset private context is missing: ${task.id}.`);\n  }\n  for (const reward of rewards) {\n    const implementation = reward.implementation;\n    const references = [...reward.assets, ...(\"verifierRef\" in implementation ? [implementation.verifierRef] : []), ...(\"rubricRef\" in implementation ? [implementation.rubricRef] : []), ...(\"inputContract\" in implementation ? [implementation.inputContract] : [])];\n    for (const reference of references) {\n      const asset = assets.find(asset => asset.id === reference.id);\n      if (!asset || reference.visibility === \"policy\") throw new Error(`Taskset Reward requires its private asset: ${reference.id}.`);\n      verifyLearningTextAsset(asset, reference);\n    }\n  }\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": ["asset", "z", "EnvironmentReleaseSchema", "VerifierSetReleaseSchema", "createLearningTextAsset", "sealLearningContent", "verifyLearningTextAsset", "z", "EnvironmentReleaseSchema", "VerifierSetReleaseSchema", "sealLearningContent", "createLearningTextAsset", "verifyLearningTextAsset", "z", "verifyEnvironmentRelease", "verifyVerifierSetRelease", "learningRef", "sealLearningContent", "verifyLearningTextAsset", "z", "sealLearningContent", "learningRef", "verifyEnvironmentRelease", "verifyVerifierSetRelease", "verifyLearningTextAsset", "asset"]
+}

package/dist/chunk-747CMU2Y.js

@@ -0,0 +1,222 @@
+import {
+  ModelStarterExecutionSchema,
+  validateModelStarterExecution
+} from "./chunk-65D4C7HP.js";
+import {
+  ModelProjectBaseModelSchema,
+  ModelProjectTrainingMethodSchema,
+  ModelProjectVersionedRefSchema,
+  canonicalSha256
+} from "./chunk-5PRP457R.js";
+
+// src/model-starters.ts
+import { z } from "zod";
+import { TasksetReleaseSchema, assertTasksetRelease } from "@openpond/evals/tasksets";
+import { LearningTextAssetSchema, TaskDefinitionSchema, learningRef, sameLearningRef, sealLearningContent } from "@openpond/evals/learning";
+import { RewardBindingSchema, RewardReleaseSchema, compileBoundGraders } from "@openpond/evals/rewards";
+import { assertBoundedTaskJson, validateTaskValue } from "@openpond/evals/task-schema";
+var IdSchema = z.string().trim().min(1).max(500);
+var RefSchema = ModelProjectVersionedRefSchema;
+var ModelStarterContentSchema = z.object({
+  schemaVersion: z.literal("openpond.modelStarter.v1"),
+  id: IdSchema,
+  revision: z.number().int().positive(),
+  name: z.string().trim().min(1).max(200),
+  description: z.string().trim().min(1).max(2e3),
+  category: z.enum(["extraction", "support", "operations", "knowledge", "coding", "writing", "classification"]),
+  taskset: RefSchema,
+  taskDefinition: RefSchema,
+  rewardBinding: RefSchema,
+  rewards: z.array(RefSchema).min(1).max(100),
+  assets: z.array(RefSchema).max(1e3),
+  previewTaskIds: z.array(IdSchema).min(1).max(8),
+  startingModel: ModelProjectBaseModelSchema,
+  supportedMethods: z.array(ModelProjectTrainingMethodSchema).min(1).max(8),
+  defaultMethod: ModelProjectTrainingMethodSchema,
+  provenance: z.object({ author: z.string().min(1).max(200), license: z.string().min(1).max(200), sourceDescription: z.string().min(1).max(2e3) }).strict(),
+  // These are references to real results. Package publication does not create
+  // evidence, qualify a starter, or enable continuous learning.
+  evidence: z.object({ verifierFixtures: RefSchema.nullable(), baseline: RefSchema.nullable(), training: RefSchema.nullable(), evaluation: RefSchema.nullable() }).strict()
+}).strict().superRefine((starter, context) => {
+  if (!starter.supportedMethods.includes(starter.defaultMethod)) context.addIssue({ code: "custom", path: ["defaultMethod"], message: "The default method must be supported by the package." });
+  for (const field of ["rewards", "assets"]) {
+    if (new Set(starter[field].map((ref) => ref.id)).size !== starter[field].length) context.addIssue({ code: "custom", path: [field], message: "Dependency identities must be unique." });
+  }
+  if (new Set(starter.previewTaskIds).size !== starter.previewTaskIds.length) context.addIssue({ code: "custom", path: ["previewTaskIds"], message: "Preview tasks must be unique." });
+});
+var ModelStarterSchema = ModelStarterContentSchema.safeExtend({ contentHash: z.string().regex(/^[a-f0-9]{64}$/) });
+var ResolvedModelStarterSchema = z.object({
+  starter: ModelStarterSchema,
+  taskset: TasksetReleaseSchema,
+  taskDefinition: TaskDefinitionSchema,
+  rewardBinding: RewardBindingSchema,
+  rewards: z.array(RewardReleaseSchema).min(1).max(100),
+  assets: z.array(LearningTextAssetSchema).max(1e3),
+  execution: ModelStarterExecutionSchema.optional()
+}).strict();
+var ModelStarterPrivacyReviewSchema = z.object({
+  schemaVersion: z.literal("openpond.modelStarterPrivacyReview.v1"),
+  disposition: z.literal("synthetic_only"),
+  reviewedBy: z.string().trim().min(1).max(500),
+  reviewedAt: z.iso.datetime(),
+  reviewedContentHash: z.string().regex(/^[a-f0-9]{64}$/),
+  note: z.string().trim().min(1).max(2e3)
+}).strict();
+function modelStarterPrivacyContentHash(value) {
+  const { contentHash: _starterHash, ...starter } = value.starter;
+  const { contentHash: _tasksetHash, ...taskset } = value.taskset;
+  const { contentHash: _referenceHash, ...tasksetRef } = starter.taskset;
+  const metadata = { ...taskset.metadata };
+  const authoring = metadata.starterAuthoring;
+  if (authoring && typeof authoring === "object" && !Array.isArray(authoring)) {
+    const { privacyReview: _review, ...content } = authoring;
+    metadata.starterAuthoring = content;
+  }
+  return sealLearningContent({ ...value, starter: { ...starter, taskset: tasksetRef }, taskset: { ...taskset, metadata } }).contentHash;
+}
+var ModelStarterCreationIntentSchema = z.object({
+  profileId: IdSchema,
+  modelId: IdSchema,
+  name: z.string().trim().min(1).max(200),
+  starter: RefSchema,
+  startingModel: ModelProjectBaseModelSchema,
+  method: ModelProjectTrainingMethodSchema,
+  rewardBindingRef: RefSchema.nullable().optional()
+}).strict();
+var ModelStarterCreationRequestSchema = ModelStarterCreationIntentSchema.extend({
+  schemaVersion: z.literal("openpond.modelStarterCreation.v1"),
+  operationId: IdSchema
+}).strict();
+function parseModelStarterCreationRequest(value) {
+  assertBoundedTaskJson(value, 64 * 1024);
+  return ModelStarterCreationRequestSchema.parse(value);
+}
+async function createModelStarterCreationRequest(value) {
+  assertBoundedTaskJson(value, 64 * 1024);
+  const intent = ModelStarterCreationIntentSchema.parse(value);
+  return parseModelStarterCreationRequest({
+    ...intent,
+    schemaVersion: "openpond.modelStarterCreation.v1",
+    operationId: `model-starter:${await canonicalSha256(intent)}`
+  });
+}
+function validateModelStarterCreation(value, packageValue) {
+  const request = parseModelStarterCreationRequest(value);
+  const resolved = validateResolvedModelStarter(packageValue);
+  if (!sameLearningRef(request.starter, learningRef(resolved.starter))) throw new Error("Starter creation references a different package revision.");
+  if (!resolved.starter.supportedMethods.includes(request.method)) throw new Error("The selected training method is not supported by this starter.");
+  return { request, resolved };
+}
+function previewModelStarter(value) {
+  const { starter, taskset, taskDefinition, rewardBinding, rewards } = validateResolvedModelStarter(value);
+  return {
+    starter,
+    inputSchema: taskDefinition.inputSchema,
+    outputSchema: taskDefinition.outputSchema,
+    reward: {
+      name: rewardBinding.name,
+      description: rewardBinding.description,
+      checks: rewardBinding.sources.map((source) => {
+        const reward = rewards.find((reward2) => sameLearningRef(source.reward, learningRef(reward2)));
+        return { name: reward.name, description: reward.description, kind: reward.implementation.kind, role: source.role, weight: source.weight, required: source.required, hardGate: source.hardGate };
+      })
+    },
+    tasks: starter.previewTaskIds.map((id) => {
+      const task = taskset.tasks.find((task2) => task2.id === id);
+      return { id: task.id, input: task.input, policyVisibleContext: task.policyVisibleContext };
+    }),
+    counts: {
+      train: taskset.tasks.filter((task) => task.split === "train").length,
+      validation: taskset.tasks.filter((task) => task.split === "validation").length,
+      frozenEvaluation: taskset.tasks.filter((task) => task.split === "frozen_eval").length
+    }
+  };
+}
+function validateResolvedModelStarter(value) {
+  assertBoundedTaskJson(value, 16 * 1024 * 1024);
+  const resolved = ResolvedModelStarterSchema.parse(value);
+  const { starter, taskset, taskDefinition, rewardBinding, rewards, assets } = resolved;
+  const authoring = taskset.metadata.starterAuthoring;
+  if (authoring && typeof authoring === "object" && !Array.isArray(authoring) && "privacyReview" in authoring) {
+    const review = ModelStarterPrivacyReviewSchema.parse(authoring.privacyReview);
+    if (review.reviewedContentHash !== modelStarterPrivacyContentHash(resolved)) throw new Error("Starter privacy review differs from the published contents.");
+  }
+  const resources = [starter, taskset, taskDefinition, rewardBinding, ...rewards, ...assets];
+  for (const resource of resources) {
+    const { contentHash, ...content } = resource;
+    if (sealLearningContent(content).contentHash !== contentHash) throw new Error(`Starter resource integrity failed: ${resource.id}.`);
+  }
+  assertTasksetRelease(taskset);
+  validateModelStarterExecution(resolved.execution, taskset, assets);
+  function exact(expected, resource) {
+    if (!sameLearningRef(expected, learningRef(resource))) throw new Error(`Starter dependency mismatch: ${expected.id}.`);
+  }
+  exact(starter.taskset, taskset);
+  exact(starter.taskDefinition, taskDefinition);
+  exact(starter.rewardBinding, rewardBinding);
+  exact(taskDefinition.rewardBinding, rewardBinding);
+  if (rewardBinding.recipeRef) throw new Error("Starter binding recipes must be resolved into a standalone binding before publication.");
+  const { policy, environment, environmentRelease, tools, capabilities, verifierSetRelease } = taskset;
+  const execution = { policy, environment, ...environmentRelease ? { environmentRelease } : {}, tools, capabilities, ...verifierSetRelease ? { verifierSetRelease } : {} };
+  if (sealLearningContent(execution).contentHash !== sealLearningContent(taskDefinition.execution).contentHash) throw new Error("Starter execution context differs from its task format.");
+  if (sealLearningContent({ graders: taskset.graders }).contentHash !== sealLearningContent({ graders: compileBoundGraders(rewardBinding, rewards) }).contentHash) throw new Error("Starter executable graders differ from its Reward binding.");
+  for (const [references, values] of [[starter.rewards, rewards], [starter.assets, assets]]) {
+    if (references.length !== values.length || new Set(values.map((resource) => resource.id)).size !== values.length) throw new Error("Starter dependency inventory mismatch.");
+    for (const ref of references) {
+      const resource = values.find((value2) => value2.id === ref.id);
+      if (!resource) throw new Error(`Starter dependency is missing: ${ref.id}.`);
+      exact(ref, resource);
+    }
+  }
+  for (const source of rewardBinding.sources) {
+    const reward = rewards.find((reward2) => reward2.id === source.reward.id);
+    if (!reward) throw new Error(`Starter Reward is missing: ${source.reward.id}.`);
+    exact(source.reward, reward);
+  }
+  for (const reward of rewards) {
+    const implementation = reward.implementation;
+    const references = [
+      ...reward.assets,
+      ..."verifierRef" in implementation ? [implementation.verifierRef] : [],
+      ..."rubricRef" in implementation ? [implementation.rubricRef] : [],
+      ..."inputContract" in implementation ? [implementation.inputContract] : []
+    ];
+    for (const ref of references) {
+      const asset = assets.find((asset2) => asset2.id === ref.id);
+      if (!asset || sealLearningContent(asset.asset).contentHash !== sealLearningContent(ref).contentHash) throw new Error(`Starter Reward source is missing or changed: ${ref.id}.`);
+      if (ref.visibility === "policy") throw new Error(`Starter Reward source must remain private to its evaluator: ${ref.id}.`);
+    }
+  }
+  if (new Set(taskset.tasks.map((task) => task.id)).size !== taskset.tasks.length) throw new Error("Starter task identities must be unique.");
+  const inputSplits = /* @__PURE__ */ new Map();
+  for (const task of taskset.tasks) {
+    if (task.policyVisibleContext.instructions !== taskDefinition.instructions) throw new Error(`Starter task does not carry its declared model instructions: ${task.id}.`);
+    const inputHash = sealLearningContent({ input: task.input, context: task.policyVisibleContext }).contentHash;
+    const priorSplit = inputSplits.get(inputHash);
+    if (priorSplit && priorSplit !== task.split) throw new Error("Starter policy input appears in multiple splits.");
+    inputSplits.set(inputHash, task.split);
+    if (!validateTaskValue(taskDefinition.inputSchema, task.input).valid) throw new Error(`Starter task input does not match its format: ${task.id}.`);
+    if (task.expectedOutput !== null && !validateTaskValue(taskDefinition.outputSchema, task.expectedOutput).valid) throw new Error(`Starter expected output does not match its format: ${task.id}.`);
+  }
+  for (const id of starter.previewTaskIds) {
+    const task = taskset.tasks.find((task2) => task2.id === id);
+    if (!task || task.split === "frozen_eval") throw new Error(`Starter preview task is unavailable: ${id}.`);
+  }
+  return resolved;
+}
+
+export {
+  ModelStarterContentSchema,
+  ModelStarterSchema,
+  ResolvedModelStarterSchema,
+  ModelStarterPrivacyReviewSchema,
+  modelStarterPrivacyContentHash,
+  ModelStarterCreationIntentSchema,
+  ModelStarterCreationRequestSchema,
+  parseModelStarterCreationRequest,
+  createModelStarterCreationRequest,
+  validateModelStarterCreation,
+  previewModelStarter,
+  validateResolvedModelStarter
+};
+//# sourceMappingURL=chunk-747CMU2Y.js.map