@openpond/evals 0.6.0 → 0.7.0

package/dist/rewards.js

@@ -0,0 +1,230 @@
+import { LearningDomainError } from "./learning/errors.js";
+import { z } from "zod";
+import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash } from "@openpond/harness";
+import { gradeEvidence } from "./graders.js";
+import { CustomVerifierGraderSpecSchema, DeterministicGraderSpecSchema, GraderSpecSchema, HumanGraderSpecSchema, ModelJudgeGraderSpecSchema } from "./tasksets.js";
+import { assertBoundedTaskJson, validateTaskSchema } from "./task-schema.js";
+const bindingFields = { id: true, version: true, weight: true, hardGate: true, rewardEligible: true, privileged: true };
+export const RewardImplementationSchema = z.union([
+    DeterministicGraderSpecSchema.omit(bindingFields),
+    ModelJudgeGraderSpecSchema.omit(bindingFields),
+    CustomVerifierGraderSpecSchema.omit(bindingFields),
+    HumanGraderSpecSchema.omit(bindingFields),
+    z.object({ kind: z.literal("learned_model"), modelVersion: ImmutableReleaseRefSchema, inputContract: ImmutableAssetRefSchema }).strict(),
+]);
+export const RewardReleaseContentSchema = z.object({
+    schemaVersion: z.literal("openpond.rewardRelease.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    name: z.string().trim().min(1).max(500),
+    description: z.string().max(10_000),
+    implementation: RewardImplementationSchema,
+    rawScore: z.object({ minimum: z.number().finite(), maximum: z.number().finite() }).strict(),
+    assets: z.array(ImmutableAssetRefSchema).max(1_000),
+}).strict().superRefine((reward, context) => {
+    if (reward.rawScore.minimum >= reward.rawScore.maximum)
+        context.addIssue({ code: "custom", path: ["rawScore"], message: "A raw score contract requires minimum < maximum." });
+    if (reward.implementation.kind !== "learned_model" && (reward.rawScore.minimum !== 0 || reward.rawScore.maximum !== 1))
+        context.addIssue({ code: "custom", path: ["rawScore"], message: "Portable graders currently return scores in [0, 1]." });
+    if (reward.implementation.kind === "schema") {
+        const report = validateTaskSchema(reward.implementation.config.jsonSchema);
+        if (!report.valid)
+            context.addIssue({ code: "custom", path: ["implementation", "config", "jsonSchema"], message: report.issues[0].message });
+    }
+});
+export const RewardReleaseSchema = RewardReleaseContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export const RewardReleaseRefSchema = ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict();
+export const RewardNormalizationSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("identity") }).strict(),
+    z.object({ kind: z.literal("linear"), minimum: z.number().finite(), maximum: z.number().finite(), direction: z.enum(["higher", "lower"]) }).strict(),
+]);
+export const RewardBindingSourceSchema = z.object({
+    graderId: ReleaseIdSchema,
+    reward: RewardReleaseRefSchema,
+    role: z.enum(["training", "evaluation"]),
+    normalization: RewardNormalizationSchema,
+    weight: z.number().nonnegative().max(1_000),
+    required: z.boolean(),
+    hardGate: z.boolean(),
+    privileged: z.boolean(),
+    fixtureRefs: z.array(ImmutableReleaseRefSchema).max(1_000),
+}).strict();
+export const RewardBindingContentSchema = z.object({
+    schemaVersion: z.literal("openpond.rewardBinding.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    name: z.string().trim().min(1).max(500).optional(),
+    description: z.string().max(10_000).optional(),
+    recipeRef: RewardReleaseRefSchema.optional(),
+    sources: z.array(RewardBindingSourceSchema).min(1).max(100),
+    aggregation: z.literal("weighted_mean"),
+    unscorable: z.literal("exclude_optional_require_all_required"),
+}).strict().superRefine((binding, context) => {
+    if (new Set(binding.sources.map((source) => source.graderId)).size !== binding.sources.length)
+        context.addIssue({ code: "custom", path: ["sources"], message: "Bound grader identities must be unique." });
+    if (!binding.sources.some((source) => source.weight > 0))
+        context.addIssue({ code: "custom", path: ["sources"], message: "A binding needs at least one positively weighted source." });
+    for (const [index, source] of binding.sources.entries()) {
+        if (source.hardGate && !source.required)
+            context.addIssue({ code: "custom", path: ["sources", index], message: "A hard gate must be required." });
+        if (source.normalization.kind === "linear" && source.normalization.minimum >= source.normalization.maximum)
+            context.addIssue({ code: "custom", path: ["sources", index, "normalization"], message: "Linear normalization requires minimum < maximum." });
+    }
+});
+export const RewardBindingSchema = RewardBindingContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export const BoundRewardResultSchema = z.object({
+    graderId: ReleaseIdSchema,
+    reward: RewardReleaseRefSchema,
+    role: z.enum(["training", "evaluation"]),
+    status: z.enum(["scored", "pending", "unavailable", "failed"]),
+    rawScore: z.number().finite().nullable(),
+    normalizedScore: z.number().min(0).max(1).nullable(),
+    passed: z.boolean().nullable(),
+    evidenceHashes: z.array(ReleaseHashSchema).max(1_000),
+    message: z.string().max(20_000).nullable(),
+}).strict();
+export const RewardCompositionContentSchema = z.object({
+    schemaVersion: z.literal("openpond.rewardComposition.v1"),
+    binding: RewardReleaseRefSchema,
+    taskHash: ReleaseHashSchema,
+    outputHash: ReleaseHashSchema,
+    results: z.array(BoundRewardResultSchema).min(1).max(100),
+    training: z.object({ status: z.enum(["scored", "unscorable", "not_configured"]), score: z.number().min(0).max(1).nullable(), passed: z.boolean().nullable() }).strict(),
+    evaluation: z.object({ status: z.enum(["scored", "unscorable", "not_configured"]), score: z.number().min(0).max(1).nullable(), passed: z.boolean().nullable() }).strict(),
+}).strict();
+export const RewardCompositionSchema = RewardCompositionContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export function createRewardRelease(input) {
+    assertBoundedTaskJson(input);
+    const content = RewardReleaseContentSchema.parse(input);
+    return RewardReleaseSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+export function createRewardBinding(input, rewards) {
+    const content = RewardBindingContentSchema.parse(input);
+    const binding = RewardBindingSchema.parse({ ...content, contentHash: contentHash(content) });
+    resolveBoundRewards(binding, rewards);
+    return binding;
+}
+export function resolveBoundRewards(input, rewards) {
+    const binding = RewardBindingSchema.parse(input);
+    assertRewardHash(binding);
+    return binding.sources.map((source) => {
+        const reward = rewards.find((candidate) => candidate.id === source.reward.id && candidate.revision === source.reward.revision && candidate.contentHash === source.reward.contentHash);
+        if (!reward)
+            throw new LearningDomainError("reward_release_missing", 422, source.graderId);
+        const parsed = RewardReleaseSchema.parse(reward);
+        assertRewardHash(parsed);
+        if (parsed.implementation.kind === "human" && source.role === "training")
+            throw new LearningDomainError("human_reward_not_executable", 422, source.graderId);
+        if (source.normalization.kind === "identity" && (parsed.rawScore.minimum < 0 || parsed.rawScore.maximum > 1))
+            throw new LearningDomainError("reward_normalization_required", 422, source.graderId);
+        if (source.normalization.kind === "linear" && (source.normalization.minimum !== parsed.rawScore.minimum || source.normalization.maximum !== parsed.rawScore.maximum))
+            throw new LearningDomainError("reward_normalization_contract_mismatch", 422, source.graderId);
+        return { source, reward: parsed };
+    });
+}
+export function compileBoundGraders(binding, rewards) {
+    return resolveBoundRewards(binding, rewards).map(({ source, reward }) => {
+        if (reward.implementation.kind === "learned_model")
+            throw new LearningDomainError("learned_reward_requires_model_execution_adapter");
+        return compileSource(source, reward);
+    });
+}
+export async function executeRewardBinding(input) {
+    const resolved = resolveBoundRewards(input.binding, input.rewards);
+    const results = [];
+    for (const { source, reward } of resolved) {
+        input.signal?.throwIfAborted();
+        const result = { graderId: source.graderId, reward: source.reward, role: source.role, status: "unavailable", rawScore: null, normalizedScore: null, passed: null, evidenceHashes: [], message: null };
+        try {
+            if (reward.implementation.kind === "human") {
+                result.status = "pending";
+                result.message = "Human review is pending.";
+            }
+            else if (reward.implementation.kind === "learned_model") {
+                if (!input.learnedReward)
+                    result.message = "Learned reward execution is not configured.";
+                else {
+                    const scored = await input.learnedReward({ reward, task: input.task, evidence: input.evidence, signal: input.signal });
+                    Object.assign(result, { status: "scored", ...scored });
+                }
+            }
+            else {
+                const [evidence] = await gradeEvidence({ task: input.task, evidence: input.evidence, graders: [compileSource(source, reward)], modelJudge: input.modelJudge, customVerifier: input.customVerifier });
+                if (!evidence)
+                    throw new LearningDomainError("reward_evidence_missing");
+                Object.assign(result, { status: evidence.score === null ? "unavailable" : "scored", rawScore: evidence.score, passed: evidence.score === null ? null : evidence.passed, evidenceHashes: [evidence.contentHash], message: evidence.feedback.join("\n") });
+            }
+            if (result.status === "scored") {
+                if (result.rawScore === null || !Number.isFinite(result.rawScore) || result.rawScore < reward.rawScore.minimum || result.rawScore > reward.rawScore.maximum)
+                    throw new LearningDomainError("reward_raw_score_outside_contract");
+                const normalization = source.normalization;
+                result.normalizedScore = normalization.kind === "identity" ? result.rawScore : (result.rawScore - normalization.minimum) / (normalization.maximum - normalization.minimum);
+                if (normalization.kind === "linear" && normalization.direction === "lower")
+                    result.normalizedScore = 1 - result.normalizedScore;
+            }
+        }
+        catch (error) {
+            input.signal?.throwIfAborted();
+            Object.assign(result, { status: "failed", rawScore: null, normalizedScore: null, passed: null, message: error instanceof Error ? error.message : "Reward execution failed." });
+        }
+        results.push(BoundRewardResultSchema.parse(result));
+    }
+    return composeBoundRewards({ binding: input.binding, taskHash: contentHash(input.task), outputHash: contentHash(input.evidence), results });
+}
+export function composeBoundRewards(input) {
+    const binding = RewardBindingSchema.parse(input.binding);
+    assertRewardHash(binding);
+    const results = input.results.map((result) => BoundRewardResultSchema.parse(result));
+    if (results.length !== binding.sources.length || new Set(results.map((result) => result.graderId)).size !== results.length)
+        throw new LearningDomainError("reward_result_set_incomplete");
+    for (const source of binding.sources) {
+        const result = results.find((candidate) => candidate.graderId === source.graderId);
+        if (!result || contentHash(result.reward) !== contentHash(source.reward) || result.role !== source.role)
+            throw new LearningDomainError("reward_result_binding_mismatch");
+        if ((result.status === "scored") !== (result.rawScore !== null && result.normalizedScore !== null && result.passed !== null))
+            throw new LearningDomainError("reward_result_score_state_invalid");
+        if (result.status !== "scored" && (result.rawScore !== null || result.normalizedScore !== null || result.passed !== null))
+            throw new LearningDomainError("unscorable_reward_contains_score");
+        if (result.status === "scored") {
+            const transform = source.normalization;
+            const normalized = transform.kind === "identity" ? result.rawScore : (result.rawScore - transform.minimum) / (transform.maximum - transform.minimum);
+            const expected = transform.kind === "linear" && transform.direction === "lower" ? 1 - normalized : normalized;
+            if (Math.abs(expected - result.normalizedScore) > 1e-12)
+                throw new LearningDomainError("reward_normalization_mismatch");
+        }
+    }
+    const content = RewardCompositionContentSchema.parse({
+        schemaVersion: "openpond.rewardComposition.v1",
+        binding: { id: binding.id, revision: binding.revision, contentHash: binding.contentHash },
+        taskHash: input.taskHash,
+        outputHash: input.outputHash,
+        results,
+        training: aggregate("training"),
+        evaluation: aggregate("evaluation"),
+    });
+    return RewardCompositionSchema.parse({ ...content, contentHash: contentHash(content) });
+    function aggregate(role) {
+        const selected = binding.sources.filter((source) => source.role === role).map((source) => ({ source, result: results.find((candidate) => candidate.graderId === source.graderId) }));
+        if (!selected.length)
+            return { status: "not_configured", score: null, passed: null };
+        if (selected.some(({ source, result }) => source.required && result.status !== "scored"))
+            return { status: "unscorable", score: null, passed: null };
+        const scored = selected.filter(({ result }) => result.status === "scored");
+        const weight = scored.reduce((sum, { source }) => sum + source.weight, 0);
+        if (weight === 0)
+            return { status: "unscorable", score: null, passed: null };
+        const gated = scored.some(({ source, result }) => source.hardGate && !result.passed);
+        return { status: "scored", score: gated ? 0 : scored.reduce((sum, { source, result }) => sum + source.weight * result.normalizedScore, 0) / weight, passed: !gated && scored.every(({ result }) => result.passed) };
+    }
+}
+export function assertRewardHash(value) {
+    assertBoundedTaskJson(value);
+    if (contentHash(withoutRewardHash(value)) !== value.contentHash)
+        throw new LearningDomainError("reward_content_hash_mismatch");
+}
+function withoutRewardHash(value) { const { contentHash: _hash, ...content } = value; return content; }
+function compileSource(source, reward) {
+    if (reward.implementation.kind === "learned_model")
+        throw new LearningDomainError("learned_reward_requires_model_execution_adapter");
+    return GraderSpecSchema.parse({ ...reward.implementation, id: source.graderId, version: String(reward.revision), weight: source.weight, hardGate: source.hardGate, rewardEligible: source.role === "training", privileged: source.privileged });
+}

package/dist/task-schema.js

@@ -0,0 +1,142 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { contentHash } from "@openpond/harness";
+export const TASK_JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+export const TASK_VALUE_MAX_BYTES = 1_048_576;
+export const TASK_SCHEMA_MAX_BYTES = 32_768;
+const validators = new Map();
+const schemaMaps = new Set(["properties", "$defs", "dependentSchemas"]);
+const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const schemaChildren = new Set(["items", "additionalProperties", "not", "if", "then", "else", "contains", "unevaluatedProperties", "unevaluatedItems", "propertyNames"]);
+const unsupported = new Set(["pattern", "patternProperties", "format", "$id", "$anchor", "$dynamicAnchor", "$dynamicRef", "$recursiveRef", "$recursiveAnchor", "$async", "$data", "contentSchema"]);
+/** Bound producer-controlled JSON before hashing, schema compilation or validation. */
+export function assertBoundedTaskJson(value, maxBytes = TASK_VALUE_MAX_BYTES) {
+    const pending = [{ value, depth: 0 }];
+    const seen = new Set();
+    let nodes = 0;
+    while (pending.length) {
+        const item = pending.pop();
+        if (item.exit) {
+            seen.delete(item.value);
+            continue;
+        }
+        if (++nodes > 100_000 || item.depth > 48)
+            throw new Error("task_json_complexity_exceeded");
+        if (item.value === null || typeof item.value === "string" || typeof item.value === "boolean")
+            continue;
+        if (typeof item.value === "number" && Number.isFinite(item.value))
+            continue;
+        if (typeof item.value !== "object")
+            throw new Error("task_json_value_invalid");
+        if (seen.has(item.value))
+            throw new Error("task_json_cycle");
+        seen.add(item.value);
+        pending.push({ ...item, exit: true });
+        const prototype = Object.getPrototypeOf(item.value);
+        if (!Array.isArray(item.value) && prototype !== Object.prototype && prototype !== null)
+            throw new Error("task_json_object_invalid");
+        if (Object.getOwnPropertySymbols(item.value).length)
+            throw new Error("task_json_symbol_invalid");
+        if (Object.hasOwn(item.value, "toJSON"))
+            throw new Error("task_json_serializer_invalid");
+        if (Array.isArray(item.value) && (item.value.length > 10_000 || Object.keys(item.value).length !== item.value.length))
+            throw new Error("task_json_array_invalid");
+        for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(item.value))) {
+            if (descriptor.get || descriptor.set)
+                throw new Error("task_json_accessor_invalid");
+            if (Array.isArray(item.value) && key !== "length" && (!/^(0|[1-9]\d*)$/u.test(key) || Number(key) >= item.value.length))
+                throw new Error("task_json_array_invalid");
+            if (descriptor.enumerable)
+                pending.push({ value: descriptor.value, depth: item.depth + 1 });
+        }
+    }
+    if (new TextEncoder().encode(JSON.stringify(value)).byteLength > maxBytes)
+        throw new Error("task_json_size_exceeded");
+}
+/** No remote resolution, custom code, data mutation, regex or format plugins. */
+export function validateTaskSchema(schema) {
+    try {
+        validator(schema);
+        return { valid: true, issues: [] };
+    }
+    catch (error) {
+        return { valid: false, issues: [{ path: "", code: "task_schema_invalid", message: error instanceof Error ? error.message : "Task schema is invalid." }] };
+    }
+}
+export function validateTaskValue(schema, value) {
+    try {
+        assertBoundedTaskJson(value);
+        const validate = validator(schema);
+        const valid = validate(value);
+        return {
+            valid,
+            issues: valid ? [] : (validate.errors ?? []).slice(0, 20).map((error) => ({
+                path: error.instancePath,
+                code: error.keyword,
+                message: error.message ?? "Value does not match the task schema.",
+            })),
+        };
+    }
+    catch (error) {
+        return { valid: false, issues: [{ path: "", code: "task_validation_unavailable", message: error instanceof Error ? error.message : "Task validation failed." }] };
+    }
+}
+function validator(schema) {
+    assertBoundedTaskJson(schema, TASK_SCHEMA_MAX_BYTES);
+    inspectSchema(schema, schema, new Set(), 0, { remaining: 2_048 });
+    const hash = contentHash(schema);
+    const cached = validators.get(hash);
+    if (cached)
+        return cached;
+    const ajv = new Ajv2020({ allErrors: false, ownProperties: true, strict: true, strictTypes: false, strictTuples: false, strictRequired: false, validateFormats: false, inlineRefs: false, loopRequired: 32, loopEnum: 32 });
+    const compiled = ajv.compile(schema);
+    if (validators.size >= 64)
+        validators.delete(validators.keys().next().value);
+    validators.set(hash, compiled);
+    return compiled;
+}
+function inspectSchema(value, root, ancestors, depth, budget) {
+    if (--budget.remaining < 0)
+        throw new Error("Task schema reference expansion exceeds the validation budget.");
+    if (typeof value === "boolean")
+        return;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("A task schema must be an object or boolean.");
+    if (depth > 24 || ancestors.has(value))
+        throw new Error("Recursive or deeply nested task schemas are not supported.");
+    const next = new Set(ancestors).add(value);
+    const schema = value;
+    if (schema.$schema !== undefined && schema.$schema !== TASK_JSON_SCHEMA_DIALECT)
+        throw new Error(`Task schemas must use ${TASK_JSON_SCHEMA_DIALECT}.`);
+    for (const [key, child] of Object.entries(schema)) {
+        if (unsupported.has(key))
+            throw new Error(`Task schema keyword ${key} is not supported by the bounded validator.`);
+        if (key === "$ref") {
+            if (typeof child !== "string" || !child.startsWith("#/$defs/"))
+                throw new Error("Task schema references must be local JSON pointers into $defs.");
+            let target = root;
+            for (const segment of child.slice(2).split("/")) {
+                if (/~(?![01])/u.test(segment))
+                    throw new Error("Invalid task schema JSON pointer.");
+                const decoded = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+                if (!target || typeof target !== "object" || !Object.hasOwn(target, decoded))
+                    throw new Error(`Task schema reference ${child} is missing.`);
+                target = target[decoded];
+            }
+            inspectSchema(target, root, next, depth + 1, budget);
+        }
+        else if (schemaMaps.has(key)) {
+            if (!child || typeof child !== "object" || Array.isArray(child))
+                throw new Error(`Invalid schema map ${key}.`);
+            for (const entry of Object.values(child))
+                inspectSchema(entry, root, next, depth + 1, budget);
+        }
+        else if (schemaArrays.has(key)) {
+            if (!Array.isArray(child) || child.length > 32)
+                throw new Error(`Schema ${key} must contain at most 32 alternatives.`);
+            for (const entry of child)
+                inspectSchema(entry, root, next, depth + 1, budget);
+        }
+        else if (schemaChildren.has(key))
+            inspectSchema(child, root, next, depth + 1, budget);
+    }
+}

package/dist/tasksets.js

@@ -40,10 +40,13 @@ export const ModelJudgeGraderSpecSchema = GraderBaseSchema.extend({
     kind: z.literal("model_judge"),
     rubricRef: ImmutableAssetRefSchema,
     calibrationStatus: z.enum(["pending", "passed", "failed"]),
+    model: z.object({ providerId: ReleaseIdSchema, modelId: ReleaseIdSchema, revision: z.string().trim().min(1).max(500).nullable() }).strict().optional(),
+    temperature: z.number().min(0).max(2).optional(),
 }).strict();
 export const CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
     kind: z.literal("custom_verifier"),
     verifierRef: ImmutableAssetRefSchema,
+    exportName: z.string().trim().min(1).max(240).optional(),
     timeoutMs: z.number().int().positive().max(300_000),
     networkPolicy: z.literal("none"),
 }).strict();

package/dist/telemetry-catalog.js

@@ -9,7 +9,7 @@ export const CORE_METRIC_CATALOG = [
     definition({ id: "attempt.failure_count", displayName: "Attempt failures", description: "Count of failed Attempts.", valueType: "counter", unit: "count", direction: "lower", aggregation: "sum", visibility: "team_visible", boundedDimensions: ["split", "failureOwner", "failureClass"] }),
     definition({ id: "optimizer.loss", displayName: "Optimizer loss", description: "Policy optimizer loss after the step.", valueType: "gauge", unit: "scalar", direction: "neutral", aggregation: "mean", visibility: "team_visible", boundedDimensions: ["split"] }),
     definition({ id: "optimizer.learning_rate", displayName: "Learning rate", description: "Optimizer learning rate after the step.", valueType: "gauge", unit: "scalar", direction: "neutral", aggregation: "last", visibility: "team_visible", boundedDimensions: ["split"] }),
-    definition({ id: "optimizer.kl", displayName: "KL divergence", description: "Sampled KL divergence from the reference policy.", valueType: "gauge", unit: "scalar", direction: "lower", aggregation: "mean", visibility: "team_visible", boundedDimensions: ["split"] }),
+    definition({ id: "optimizer.kl", displayName: "Policy update KL", description: "Sampled approximate KL between the frozen pre-update policy and the policy after the optimizer step.", valueType: "gauge", unit: "scalar", direction: "lower", aggregation: "mean", visibility: "team_visible", boundedDimensions: ["split"] }),
     definition({ id: "optimizer.entropy", displayName: "Policy entropy", description: "Observed policy entropy for trainable tokens.", valueType: "gauge", unit: "scalar", direction: "neutral", aggregation: "mean", visibility: "team_visible", boundedDimensions: ["split"] }),
     definition({ id: "optimizer.gradient_norm", displayName: "Gradient norm", description: "Gradient norm reported by the optimizer.", valueType: "gauge", unit: "scalar", direction: "neutral", aggregation: "max", visibility: "team_visible", boundedDimensions: ["split"] }),
     definition({ id: "optimizer.clip_fraction", displayName: "Clip fraction", description: "Fraction of policy updates affected by clipping.", valueType: "gauge", unit: "ratio", direction: "neutral", aggregation: "mean", visibility: "team_visible", boundedDimensions: ["split"] }),

package/dist/types/builtin-benchmarks/harness-refiner.d.ts

@@ -90,6 +90,12 @@ export declare const harnessRefinerBenchmarkRelease: {
             visibility: "policy" | "verifier" | "host_private";
         };
         calibrationStatus: "pending" | "passed" | "failed";
+        model?: {
+            providerId: string;
+            modelId: string;
+            revision: string | null;
+        } | undefined;
+        temperature?: number | undefined;
     } | {
         id: string;
         version: string;
@@ -108,6 +114,7 @@ export declare const harnessRefinerBenchmarkRelease: {
         };
         timeoutMs: number;
         networkPolicy: "none";
+        exportName?: string | undefined;
     } | {
         id: string;
         version: string;

package/dist/types/builtin-benchmarks/harness-refiner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness-refiner.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-benchmarks/harness-refiner.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqqD1C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzE,CAAC"}
+{"version":3,"file":"harness-refiner.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-benchmarks/harness-refiner.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqqD1C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzE,CAAC"}

package/dist/types/conformance.d.ts

@@ -200,6 +200,12 @@ export declare const genericToolConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
         } | {
             id: string;
             version: string;
@@ -218,6 +224,7 @@ export declare const genericToolConformance: {
             };
             timeoutMs: number;
             networkPolicy: "none";
+            exportName?: string | undefined;
         } | {
             id: string;
             version: string;
@@ -489,6 +496,12 @@ export declare const marketingPortfolioConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
         } | {
             id: string;
             version: string;
@@ -507,6 +520,7 @@ export declare const marketingPortfolioConformance: {
             };
             timeoutMs: number;
             networkPolicy: "none";
+            exportName?: string | undefined;
         } | {
             id: string;
             version: string;

package/dist/types/conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}

package/dist/types/execution-contracts.d.ts

@@ -385,6 +385,12 @@ export declare const VerifierSetReleaseContentSchema: z.ZodObject<{
             passed: "passed";
             failed: "failed";
         }>;
+        model: z.ZodOptional<z.ZodObject<{
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
@@ -405,6 +411,7 @@ export declare const VerifierSetReleaseContentSchema: z.ZodObject<{
                 host_private: "host_private";
             }>;
         }, z.core.$strict>;
+        exportName: z.ZodOptional<z.ZodString>;
         timeoutMs: z.ZodNumber;
         networkPolicy: z.ZodLiteral<"none">;
     }, z.core.$strict>, z.ZodObject<{
@@ -488,6 +495,12 @@ export declare const VerifierSetReleaseSchema: z.ZodObject<{
             passed: "passed";
             failed: "failed";
         }>;
+        model: z.ZodOptional<z.ZodObject<{
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            revision: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        temperature: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
         version: z.ZodString;
@@ -508,6 +521,7 @@ export declare const VerifierSetReleaseSchema: z.ZodObject<{
                 host_private: "host_private";
             }>;
         }, z.core.$strict>;
+        exportName: z.ZodOptional<z.ZodString>;
         timeoutMs: z.ZodNumber;
         networkPolicy: z.ZodLiteral<"none">;
     }, z.core.$strict>, z.ZodObject<{

package/dist/types/execution-contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execution-contracts.d.ts","sourceRoot":"","sources":["../../../../src/execution-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,mBAAmB;;;EAAmC,CAAC;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;EAS7B,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAYpC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,8BAA8B;;;;;EAKzC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;;EAIzC,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAa7B,CAAC;AACZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO/B,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAExB,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBvC,CAAC;AAkCH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA6D,CAAC;AACrG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGK,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"execution-contracts.d.ts","sourceRoot":"","sources":["../../../../src/execution-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,mBAAmB;;;EAAmC,CAAC;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;EAS7B,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAYpC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,8BAA8B;;;;;EAKzC,CAAC;AACH,eAAO,MAAM,8BAA8B;;;;EAIzC,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAa7B,CAAC;AACZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO/B,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAExB,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAYjC,CAAC;AACZ,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE1B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBvC,CAAC;AAkCH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA6D,CAAC;AACrG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGK,CAAC;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/types/graders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graders.d.ts","sourceRoot":"","sources":["../../../../src/graders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAA2B,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAErF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;kBAW7B,CAAC;AACZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;kBAAkF,CAAC;AAEpH,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,KAAK,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,UAAU,GAAG,eAAe,GAAG,aAAa,CAAC,CAAC,CAAC;AAC/O,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,iBAAiB,CAAA;KAAE,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,KAAK,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,UAAU,GAAG,eAAe,GAAG,aAAa,CAAC,CAAC,CAAC;AAEvP,wBAAsB,aAAa,CAAC,KAAK,EAAE;IACzC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,cAAc,CAAC,EAAE,oBAAoB,CAAC;CACvC,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAwB5B;AAkDD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"graders.d.ts","sourceRoot":"","sources":["../../../../src/graders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAA2B,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGrF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;kBAW7B,CAAC;AACZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;kBAAkF,CAAC;AAEpH,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,KAAK,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,UAAU,GAAG,eAAe,GAAG,aAAa,CAAC,CAAC,CAAC;AAC/O,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,iBAAiB,CAAA;KAAE,CAAC,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,KAAK,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,UAAU,GAAG,eAAe,GAAG,aAAa,CAAC,CAAC,CAAC;AAEvP,wBAAsB,aAAa,CAAC,KAAK,EAAE;IACzC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,cAAc,CAAC,EAAE,oBAAoB,CAAC;CACvC,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAwB5B;AA+DD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/types/index.d.ts

@@ -17,4 +17,7 @@ export * from "./telemetry-catalog.js";
 export * from "./telemetry-analysis.js";
 export * from "./telemetry-bundle.js";
 export * from "./tasksets.js";
+export * from "./task-schema.js";
+export * from "./rewards.js";
+export * from "./learning/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,WAAW,CAAC;AAC1B,cAAc,sCAAsC,CAAC;AACrD,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,WAAW,CAAC;AAC1B,cAAc,sCAAsC,CAAC;AACrD,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC"}

package/dist/types/javascript-verifier-contract.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const JavaScriptVerifierResultSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    passed: z.ZodBoolean;
+    feedback: z.ZodString;
+    evidenceRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type JavaScriptVerifierResult = z.infer<typeof JavaScriptVerifierResultSchema>;
+//# sourceMappingURL=javascript-verifier-contract.d.ts.map

package/dist/types/javascript-verifier-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-verifier-contract.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,8BAA8B;;;;;kBAKhC,CAAC;AACZ,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}

package/dist/types/javascript-verifier-node.d.ts

@@ -0,0 +1,5 @@
+import type { executeJavaScriptVerifier } from "./javascript-verifier.js";
+import { type JavaScriptVerifierResult } from "./javascript-verifier-contract.js";
+/** Resolves/rejects only after the execution owner has stopped the worker. */
+export declare function executeJavaScriptVerifierInWorker(input: Parameters<typeof executeJavaScriptVerifier>[0]): Promise<JavaScriptVerifierResult>;
+//# sourceMappingURL=javascript-verifier-node.d.ts.map

package/dist/types/javascript-verifier-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-verifier-node.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier-node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAkC,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAIlH,8EAA8E;AAC9E,wBAAsB,iCAAiC,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAqCjJ"}

package/dist/types/javascript-verifier-worker-source.d.ts

@@ -0,0 +1,2 @@
+/** Generated by the Evals build: trusted worker host plus the embedded interpreter. */
+export declare const javascriptVerifierWorkerSource: string;

package/dist/types/javascript-verifier-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=javascript-verifier-worker.d.ts.map

package/dist/types/javascript-verifier-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-verifier-worker.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier-worker.ts"],"names":[],"mappings":""}

package/dist/types/javascript-verifier.d.ts

@@ -0,0 +1,15 @@
+import { type JavaScriptVerifierResult } from "./javascript-verifier-contract.js";
+export { JavaScriptVerifierResultSchema, type JavaScriptVerifierResult } from "./javascript-verifier-contract.js";
+/**
+ * A fresh WebAssembly interpreter with no host functions, filesystem, network,
+ * timers, or module loader. Hosts should run this on a worker to remain responsive
+ * and terminate that worker when cancellation is requested.
+ */
+export declare function executeJavaScriptVerifier(input: {
+    source: string;
+    exportName?: string;
+    value: unknown;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<JavaScriptVerifierResult>;
+//# sourceMappingURL=javascript-verifier.d.ts.map

package/dist/types/javascript-verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"javascript-verifier.d.ts","sourceRoot":"","sources":["../../../../src/javascript-verifier.ts"],"names":[],"mappings":"AAGA,OAAO,EAAkC,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClH,OAAO,EAAE,8BAA8B,EAAE,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAElH;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,KAAK,EAAE;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAgCpC"}