@openpond/evals 0.5.0 → 0.7.0

package/dist/types/rewards.d.ts

@@ -0,0 +1,611 @@
+import { z } from "zod";
+import { type AttemptEvidence, type CustomVerifierRunner, type ModelJudgeRunner } from "./graders.js";
+import { type GraderSpec, type TaskRecord } from "./tasksets.js";
+export declare const RewardImplementationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodEnum<{
+        content: "content";
+        schema: "schema";
+        artifact: "artifact";
+        runtime_event: "runtime_event";
+        state: "state";
+    }>;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"model_judge">;
+    rubricRef: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    calibrationStatus: z.ZodEnum<{
+        pending: "pending";
+        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<{
+    kind: z.ZodLiteral<"custom_verifier">;
+    networkPolicy: z.ZodLiteral<"none">;
+    verifierRef: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    exportName: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"human">;
+    rubricRef: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    reviewerRole: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"learned_model">;
+    modelVersion: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    inputContract: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export declare const RewardReleaseContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    implementation: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            content: "content";
+            schema: "schema";
+            artifact: "artifact";
+            runtime_event: "runtime_event";
+            state: "state";
+        }>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"model_judge">;
+        rubricRef: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        calibrationStatus: z.ZodEnum<{
+            pending: "pending";
+            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<{
+        kind: z.ZodLiteral<"custom_verifier">;
+        networkPolicy: z.ZodLiteral<"none">;
+        verifierRef: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        exportName: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"human">;
+        rubricRef: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        reviewerRole: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"learned_model">;
+        modelVersion: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        inputContract: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+    rawScore: z.ZodObject<{
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+    }, z.core.$strict>;
+    assets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const RewardReleaseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    implementation: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodEnum<{
+            content: "content";
+            schema: "schema";
+            artifact: "artifact";
+            runtime_event: "runtime_event";
+            state: "state";
+        }>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"model_judge">;
+        rubricRef: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        calibrationStatus: z.ZodEnum<{
+            pending: "pending";
+            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<{
+        kind: z.ZodLiteral<"custom_verifier">;
+        networkPolicy: z.ZodLiteral<"none">;
+        verifierRef: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        exportName: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"human">;
+        rubricRef: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        reviewerRole: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"learned_model">;
+        modelVersion: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        inputContract: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+    rawScore: z.ZodObject<{
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+    }, z.core.$strict>;
+    assets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const RewardReleaseRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const RewardNormalizationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"identity">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"linear">;
+    minimum: z.ZodNumber;
+    maximum: z.ZodNumber;
+    direction: z.ZodEnum<{
+        higher: "higher";
+        lower: "lower";
+    }>;
+}, z.core.$strict>], "kind">;
+export declare const RewardBindingSourceSchema: z.ZodObject<{
+    graderId: z.ZodString;
+    reward: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    role: z.ZodEnum<{
+        evaluation: "evaluation";
+        training: "training";
+    }>;
+    normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"identity">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"linear">;
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+        direction: z.ZodEnum<{
+            higher: "higher";
+            lower: "lower";
+        }>;
+    }, z.core.$strict>], "kind">;
+    weight: z.ZodNumber;
+    required: z.ZodBoolean;
+    hardGate: z.ZodBoolean;
+    privileged: z.ZodBoolean;
+    fixtureRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const RewardBindingContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    recipeRef: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        graderId: z.ZodString;
+        reward: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        role: z.ZodEnum<{
+            evaluation: "evaluation";
+            training: "training";
+        }>;
+        normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"identity">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"linear">;
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+            direction: z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+            }>;
+        }, z.core.$strict>], "kind">;
+        weight: z.ZodNumber;
+        required: z.ZodBoolean;
+        hardGate: z.ZodBoolean;
+        privileged: z.ZodBoolean;
+        fixtureRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    aggregation: z.ZodLiteral<"weighted_mean">;
+    unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
+}, z.core.$strict>;
+export declare const RewardBindingSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    recipeRef: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        graderId: z.ZodString;
+        reward: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        role: z.ZodEnum<{
+            evaluation: "evaluation";
+            training: "training";
+        }>;
+        normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"identity">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"linear">;
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+            direction: z.ZodEnum<{
+                higher: "higher";
+                lower: "lower";
+            }>;
+        }, z.core.$strict>], "kind">;
+        weight: z.ZodNumber;
+        required: z.ZodBoolean;
+        hardGate: z.ZodBoolean;
+        privileged: z.ZodBoolean;
+        fixtureRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    aggregation: z.ZodLiteral<"weighted_mean">;
+    unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const BoundRewardResultSchema: z.ZodObject<{
+    graderId: z.ZodString;
+    reward: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    role: z.ZodEnum<{
+        evaluation: "evaluation";
+        training: "training";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        scored: "scored";
+        unavailable: "unavailable";
+    }>;
+    rawScore: z.ZodNullable<z.ZodNumber>;
+    normalizedScore: z.ZodNullable<z.ZodNumber>;
+    passed: z.ZodNullable<z.ZodBoolean>;
+    evidenceHashes: z.ZodArray<z.ZodString>;
+    message: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const RewardCompositionContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
+    binding: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    taskHash: z.ZodString;
+    outputHash: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        graderId: z.ZodString;
+        reward: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        role: z.ZodEnum<{
+            evaluation: "evaluation";
+            training: "training";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            scored: "scored";
+            unavailable: "unavailable";
+        }>;
+        rawScore: z.ZodNullable<z.ZodNumber>;
+        normalizedScore: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+        evidenceHashes: z.ZodArray<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    training: z.ZodObject<{
+        status: z.ZodEnum<{
+            scored: "scored";
+            unscorable: "unscorable";
+            not_configured: "not_configured";
+        }>;
+        score: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+    evaluation: z.ZodObject<{
+        status: z.ZodEnum<{
+            scored: "scored";
+            unscorable: "unscorable";
+            not_configured: "not_configured";
+        }>;
+        score: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const RewardCompositionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
+    binding: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    taskHash: z.ZodString;
+    outputHash: z.ZodString;
+    results: z.ZodArray<z.ZodObject<{
+        graderId: z.ZodString;
+        reward: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        role: z.ZodEnum<{
+            evaluation: "evaluation";
+            training: "training";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            scored: "scored";
+            unavailable: "unavailable";
+        }>;
+        rawScore: z.ZodNullable<z.ZodNumber>;
+        normalizedScore: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+        evidenceHashes: z.ZodArray<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    training: z.ZodObject<{
+        status: z.ZodEnum<{
+            scored: "scored";
+            unscorable: "unscorable";
+            not_configured: "not_configured";
+        }>;
+        score: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+    evaluation: z.ZodObject<{
+        status: z.ZodEnum<{
+            scored: "scored";
+            unscorable: "unscorable";
+            not_configured: "not_configured";
+        }>;
+        score: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type RewardRelease = z.infer<typeof RewardReleaseSchema>;
+export type RewardBinding = z.infer<typeof RewardBindingSchema>;
+export type RewardComposition = z.infer<typeof RewardCompositionSchema>;
+export type BoundRewardResult = z.infer<typeof BoundRewardResultSchema>;
+export type RewardBindingSource = z.infer<typeof RewardBindingSourceSchema>;
+export type LearnedRewardRunner = (input: {
+    reward: RewardRelease;
+    task: TaskRecord;
+    evidence: AttemptEvidence;
+    signal?: AbortSignal;
+}) => Promise<{
+    rawScore: number;
+    passed: boolean;
+    evidenceHashes: string[];
+}>;
+export declare function createRewardRelease(input: z.input<typeof RewardReleaseContentSchema>): RewardRelease;
+export declare function createRewardBinding(input: z.input<typeof RewardBindingContentSchema>, rewards: RewardRelease[]): RewardBinding;
+export declare function resolveBoundRewards(input: RewardBinding, rewards: RewardRelease[]): Array<{
+    source: RewardBindingSource;
+    reward: RewardRelease;
+}>;
+export declare function compileBoundGraders(binding: RewardBinding, rewards: RewardRelease[]): GraderSpec[];
+export declare function executeRewardBinding(input: {
+    binding: RewardBinding;
+    rewards: RewardRelease[];
+    task: TaskRecord;
+    evidence: AttemptEvidence;
+    modelJudge?: ModelJudgeRunner;
+    customVerifier?: CustomVerifierRunner;
+    learnedReward?: LearnedRewardRunner;
+    signal?: AbortSignal;
+}): Promise<RewardComposition>;
+export declare function composeBoundRewards(input: {
+    binding: RewardBinding;
+    taskHash: string;
+    outputHash: string;
+    results: BoundRewardResult[];
+}): RewardComposition;
+export declare function assertRewardHash(value: {
+    contentHash: string;
+}): void;
+//# sourceMappingURL=rewards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rewards.d.ts","sourceRoot":"","sources":["../../../../src/rewards.ts"],"names":[],"mappings":"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"}

package/dist/types/task-schema.d.ts

@@ -0,0 +1,18 @@
+export declare const TASK_JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+export declare const TASK_VALUE_MAX_BYTES = 1048576;
+export declare const TASK_SCHEMA_MAX_BYTES = 32768;
+export type TaskSchemaIssue = {
+    path: string;
+    code: string;
+    message: string;
+};
+export type TaskSchemaResult = {
+    valid: boolean;
+    issues: TaskSchemaIssue[];
+};
+/** Bound producer-controlled JSON before hashing, schema compilation or validation. */
+export declare function assertBoundedTaskJson(value: unknown, maxBytes?: number): void;
+/** No remote resolution, custom code, data mutation, regex or format plugins. */
+export declare function validateTaskSchema(schema: unknown): TaskSchemaResult;
+export declare function validateTaskValue(schema: unknown, value: unknown): TaskSchemaResult;
+//# sourceMappingURL=task-schema.d.ts.map

package/dist/types/task-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-schema.d.ts","sourceRoot":"","sources":["../../../../src/task-schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,wBAAwB,iDAAiD,CAAC;AACvF,eAAO,MAAM,oBAAoB,UAAY,CAAC;AAC9C,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAC9E,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAQ7E,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAuB,GAAG,IAAI,CA0B3F;AAED,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAOpE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAgBnF"}