@openpond/evals 0.11.16 → 0.11.17

package/dist/learning/training-handoff.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { ExperimentTargetSchema } from "../experiments.js";
+const Id = z.string().trim().min(1).max(200);
+const Hash = z.string().regex(/^[a-f0-9]{64}$/);
+const Ref = z.object({ id: Id, contentHash: Hash }).strict();
+export const TrainingHandoffOriginSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.trainingHandoffOrigin.v1"),
+    teamId: Id,
+    projectId: Id.nullable(),
+    configurationId: Id,
+    source: z
+        .object({ executionId: Id, passId: Id.nullable(), manifestHash: Hash, resultHash: Hash })
+        .strict(),
+    dataset: z
+        .object({ id: Id, revision: z.number().int().positive(), contentHash: Hash })
+        .strict(),
+    target: ExperimentTargetSchema,
+    graders: z
+        .array(z
+        .object({
+        feedbackKey: Id,
+        evaluator: Ref,
+        expectedCount: z.number().int().positive(),
+        scoredCount: z.number().int().nonnegative(),
+        score: z.number().finite().nullable(),
+    })
+        .strict())
+        .max(100),
+    contentHash: Hash,
+})
+    .strict();

package/dist/metrics-node.js

@@ -31,3 +31,5 @@ const executeMetric = async ({ source, module, exportName, scores, timeoutMs, si
 };
 const executeProcessMetric = ({ source, module, exportName, scores, timeoutMs, signal }) => executeJavaScriptIsolateInProcess({ source, exportName, value: scores, timeoutMs, signal, stripTypeScript: /\.[cm]?ts$/.test(module),
     maxResultBytes: 1_024, deterministic: true, errorPrefix: "metric" });
+/** Trusted host port for a frozen private metric; callers retain source and receipt ownership. */
+export const executeTasksetMetricWorker = executeMetric;

package/dist/profile-evaluation-target.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { ReleaseIdSchema } from "@openpond/harness";
+const RelativePathSchema = z.string().min(1).max(2000).refine(value => !value.includes("\\") && !value.includes(":") && !value.startsWith("/") && value.split("/").every(part => part !== "" && part !== "." && part !== ".."), "Evaluation paths must be portable and relative.");
+export const ProfileEvaluationTargetSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("profile") }).strict(), z.object({ kind: z.literal("workflow"), workflowId: ReleaseIdSchema }).strict(),
+    z.object({ kind: z.literal("skill"), skillPath: RelativePathSchema }).strict(), z.object({ kind: z.literal("agent_action"), actionId: ReleaseIdSchema }).strict()
+]);

package/dist/profile-evaluations.js

@@ -1,16 +1,11 @@
 import { z } from "zod";
+import { ProfileSourceCandidateSchema } from "./profile-source-candidate.js";
 import { ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash, harnessSourcePackageFiles, loadReleasedProfileWorkflowCatalogAssets, sha256, validateHarnessSourcePackage, } from "@openpond/harness";
 import { TaskSplitSchema } from "./tasksets.js";
-const RelativePathSchema = z.string().min(1).max(2_000).refine((value) => !value.includes("\\") && !value.includes(":") && !value.startsWith("/")
-    && value.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "evaluation paths must be portable and relative");
-/** Portable selection only. Taskset releases own task data and graders; run
- * manifests and evidence stay in the installation's evaluation store. */
-export const ProfileEvaluationTargetSchema = z.discriminatedUnion("kind", [
-    z.object({ kind: z.literal("profile") }).strict(),
-    z.object({ kind: z.literal("workflow"), workflowId: ReleaseIdSchema }).strict(),
-    z.object({ kind: z.literal("skill"), skillPath: RelativePathSchema }).strict(),
-    z.object({ kind: z.literal("agent_action"), actionId: ReleaseIdSchema }).strict(),
-]);
+import { ProfileEvaluationTargetSchema } from "./profile-evaluation-target.js";
+import { ProfileExternalDatasetBindingSchema } from "./profile-external-evaluation.js";
+export { ProfileEvaluationTargetSchema } from "./profile-evaluation-target.js";
+export * from "./profile-external-evaluation.js";
 export const ProfileEvaluationDefinitionSchema = z.object({
     id: ReleaseIdSchema,
     label: z.string().trim().min(1).max(240),
@@ -54,6 +49,8 @@ export const ProfileEvaluationRunSourceSchema = z.object({
     definitionHash: ReleaseHashSchema,
     target: ProfileEvaluationTargetSchema,
     environmentHash: ReleaseHashSchema,
+    externalDatasetBinding: ProfileExternalDatasetBindingSchema.optional(),
+    sourceCandidate: ProfileSourceCandidateSchema.optional(),
 }).strict();
 /** Validate component and suite references against the same Profile release. */
 export function validateProfileEvaluationCatalog(input) {

package/dist/profile-external-evaluation.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash } from "@openpond/harness";
+import { ProfileEvaluationTargetSchema } from "./profile-evaluation-target.js";
+import { TaskSplitSchema } from "./tasksets.js";
+const PopulationMemberSchema = z.object({ taskId: ReleaseIdSchema, seed: z.string().min(1).max(500), fixtureId: ReleaseIdSchema.nullable() }).strict();
+const Segment = z.string().min(1).max(200).refine(value => !["__proto__", "prototype", "constructor"].includes(value), "Use an ordinary field name.");
+const Slot = z.enum(["input", "output", "expectedOutput", "evaluatorContext"]);
+export const ProfileExternalFieldMappingsSchema = z.array(z.object({ graderId: ReleaseIdSchema, fields: z.array(z.object({ destination: Slot, path: z.array(Segment).min(1).max(20), source: Slot, sourcePath: z.array(Segment).max(20) }).strict()).max(100) }).strict()).max(100);
+const RecordedOriginSchema = z.object({ execution: ImmutableReleaseRefSchema, originalEvidence: ImmutableReleaseRefSchema, members: z.array(z.object({ caseId: ReleaseIdSchema, seed: z.string().min(1).max(500), fixtureId: ReleaseHashSchema,
+        sourceId: ReleaseIdSchema, snapshotHash: ReleaseHashSchema, boundaryRevisionHash: ReleaseHashSchema }).strict()).min(1).max(500) }).strict();
+const MeasurementSchema = z.object({ release: ImmutableReleaseRefSchema.extend({ revision: z.union([z.number().int().positive(), z.string().min(1).max(200)]) }).strict(), feedbackKey: z.string().min(1).max(240),
+    configurationHash: ReleaseHashSchema, output: z.enum(["boolean", "score", "category"]), categories: z.array(z.string().min(1).max(120)).max(50) }).strict();
+export const ProfileExternalDatasetBindingContentSchema = z.object({ schemaVersion: z.literal("openpond.profileExternalDatasetBinding.v1"), dataset: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict(),
+    packageHash: ReleaseHashSchema, profileId: ReleaseIdSchema, target: ProfileEvaluationTargetSchema, declaredProfileCatalogHash: ReleaseHashSchema.nullable(), protectedProfileClosureHash: ReleaseHashSchema,
+    recordedOrigin: RecordedOriginSchema.optional(), gradingSource: z.object({ pass: ImmutableReleaseRefSchema, evidence: ImmutableReleaseRefSchema }).strict().optional(), split: TaskSplitSchema, population: z.array(PopulationMemberSchema).min(1).max(10000), evaluators: z.array(MeasurementSchema).min(1).max(100), fieldMappingsHash: ReleaseHashSchema, fieldMappings: ProfileExternalFieldMappingsSchema,
+    environmentHash: ReleaseHashSchema, privateDatasetClosureHash: ReleaseHashSchema, criterion: z.object({ minimumPassRate: z.number().min(0).max(1), requireComplete: z.boolean() }).strict() }).strict().superRefine((value, ctx) => {
+    if (value.recordedOrigin && (value.recordedOrigin.members.length !== value.population.length || value.recordedOrigin.members.some((source, index) => source.caseId !== value.population[index].taskId || source.seed !== value.population[index].seed || source.fixtureId !== source.snapshotHash || value.population[index].fixtureId !== null)))
+        ctx.addIssue({ code: "custom", message: "Recorded-to-rerun mapping must preserve every exact ordered cutoff and seed while admitting new target attempts." });
+    if (contentHash(value.fieldMappings) !== value.fieldMappingsHash)
+        ctx.addIssue({ code: "custom", message: "Field mappings differ from their sealed hash." });
+    if (new Set(value.fieldMappings.map(row => row.graderId)).size !== value.fieldMappings.length)
+        ctx.addIssue({ code: "custom", message: "Field mappings must name each grader once." });
+    if (new Set(value.population.map(row => JSON.stringify([row.taskId, row.seed, row.fixtureId]))).size !== value.population.length)
+        ctx.addIssue({ code: "custom", message: "External Dataset population must be unique." });
+    if (new Set(value.evaluators.map(row => row.feedbackKey)).size !== value.evaluators.length)
+        ctx.addIssue({ code: "custom", message: "External Dataset feedback keys must be unique." });
+    for (const grader of value.evaluators)
+        if ((grader.output === "category") !== (grader.categories.length > 0))
+            ctx.addIssue({ code: "custom", message: "Only category grading declares categories." });
+});
+export const ProfileExternalDatasetBindingSchema = ProfileExternalDatasetBindingContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export function verifyProfileExternalDatasetBinding(raw) { const value = ProfileExternalDatasetBindingSchema.parse(raw), { contentHash: hash, ...body } = value; if (contentHash(body) !== hash)
+    throw new Error("External Dataset binding integrity failed."); return value; }
+export function createProfileExternalDatasetBinding(raw) { const value = ProfileExternalDatasetBindingContentSchema.parse(raw); return verifyProfileExternalDatasetBinding({ ...value, contentHash: contentHash(value) }); }
+export const externalDatasetDefinitionId = (binding) => `external-dataset-${verifyProfileExternalDatasetBinding(binding).contentHash.slice(0, 40)}`;

package/dist/profile-source-candidate.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+import { ImmutableReleaseRefSchema } from "@openpond/harness";
+/** An identity to resolve through the actual private hosted source owner. It is
+ * never itself an authorization or a model-artifact declaration. */
+export const ProfileSourceCandidateSchema = z.object({ candidateId: z.string().min(1).max(240), frozenRevision: z.number().int().positive(), frozenHash: z.string().regex(/^[a-f0-9]{64}$/), harnessRelease: ImmutableReleaseRefSchema, protectedClosureHash: z.string().regex(/^[a-f0-9]{64}$/) }).strict();

package/dist/rewards.js

@@ -101,8 +101,8 @@ export const RewardCompositionContentSchema = z.object({
     taskHash: ReleaseHashSchema,
     outputHash: ReleaseHashSchema,
     results: z.array(BoundRewardResultSchema).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(),
+    training: z.object({ status: z.enum(["scored", "pending", "unscorable", "not_configured"]), score: z.number().min(0).max(1).nullable(), passed: z.boolean().nullable() }).strict(),
+    evaluation: z.object({ status: z.enum(["scored", "pending", "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) {
@@ -229,8 +229,10 @@ export function composeBoundRewards(input) {
         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"))
+        if (selected.some(({ source, result }) => source.required && result.status !== "scored" && result.status !== "pending"))
             return { status: "unscorable", score: null, passed: null };
+        if (selected.some(({ source, result }) => source.required && result.status === "pending"))
+            return { status: "pending", 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)

package/dist/taskset-run-contract.js

@@ -1,3 +1,4 @@
+import { verifyProfileExternalDatasetBinding, externalDatasetDefinitionId } from "./profile-external-evaluation.js";
 import { z } from "zod";
 import { assertContentHash, contentHash, ImmutableReleaseRefSchema, MetadataSchema, ModelRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
 import { RunLimitsSchema, RuntimeTargetBindingSchema, verifyAttemptReceipt } from "./runs.js";
@@ -100,6 +101,15 @@ export function assertProfileEvaluationRunAdmission(manifest, taskset, catalogIn
     if (definition.taskIds.some((id) => tasks.get(id)?.split !== definition.split)) {
         throw new Error("Profile evaluation case is absent from its declared Taskset split.");
     }
+    if (source.externalDatasetBinding) {
+        const binding = verifyProfileExternalDatasetBinding(source.externalDatasetBinding);
+        if (source.definitionId !== externalDatasetDefinitionId(binding) || binding.dataset.id !== taskset.id || binding.dataset.revision !== taskset.revision || binding.dataset.contentHash !== taskset.contentHash
+            || binding.packageHash !== manifest.packageHash || binding.profileId !== source.profileId || contentHash(binding.target) !== contentHash(source.target) || binding.split !== definition.split
+            || binding.environmentHash !== contentHash(taskset.environment) || binding.population.length !== manifest.population.length
+            || binding.population.some((member, index) => contentHash(member) !== contentHash({ taskId: manifest.population[index].taskId, seed: manifest.population[index].seed, fixtureId: manifest.population[index].fixtureId })))
+            throw new Error("Profile external Dataset execution differs from its exact admitted recipe.");
+        return;
+    }
     const expected = new Set(definition.taskIds.flatMap((taskId) => definition.seeds.map((seed) => JSON.stringify([taskId, seed]))));
     const actual = new Set(manifest.population.map(({ taskId, seed }) => JSON.stringify([taskId, seed])));
     if (manifest.population.some((member) => member.fixtureId !== null)

package/dist/tasksets.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { CapabilityRequirementSchema, ImmutableAssetRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, ToolDeclarationSchema, assertContentHash, contentHash, } from "@openpond/harness";
 import { TasksetMetricPolicySchema } from "./metric-policy.js";
+import { HumanFormSchema } from "./human-review/contracts.js";
 export const TaskSplitSchema = z.enum(["train", "validation", "test", "frozen_eval"]);
 export const RequiredOutputContractSchema = z.object({
     path: z.string().trim().min(1).max(2_000).refine(safeRelativePath),
@@ -58,6 +59,7 @@ export const HumanGraderSpecSchema = GraderBaseSchema.extend({
     kind: z.literal("human"),
     rubricRef: ImmutableAssetRefSchema,
     reviewerRole: z.string().trim().min(1).max(500),
+    form: HumanFormSchema.optional(),
 }).strict();
 export const GraderSpecSchema = z.union([
     DeterministicGraderSpecSchema,

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

@@ -14,7 +14,7 @@ export declare const harnessRefinerBenchmarkRelease: {
         entrypoint: string;
         stateful: boolean;
         deterministicSeeds: boolean;
-        lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+        lifecycle: ("step" | "create" | "reset" | "collect" | "destroy")[];
         networkPolicy: "none" | "declared_read_only" | "declared_scoped";
         defaultTimeoutMs: number;
     };
@@ -133,6 +133,80 @@ export declare const harnessRefinerBenchmarkRelease: {
             visibility: "policy" | "verifier" | "host_private";
         };
         reviewerRole: string;
+        form?: {
+            schemaVersion: "openpond.humanForm.v1";
+            mode: "individual" | "pairwise";
+            instructions: string;
+            criteria: ({
+                id: string;
+                label: string;
+                instructions: string;
+                required: boolean;
+                allowAbstain: boolean;
+                kind: "score";
+                minimum: number;
+                maximum: number;
+                step: number;
+                requireRationale?: boolean | undefined;
+                anchors?: {
+                    value: string | number | boolean;
+                    description: string;
+                }[] | undefined;
+            } | {
+                id: string;
+                label: string;
+                instructions: string;
+                required: boolean;
+                allowAbstain: boolean;
+                kind: "category";
+                options: string[];
+                requireRationale?: boolean | undefined;
+                anchors?: {
+                    value: string | number | boolean;
+                    description: string;
+                }[] | undefined;
+            } | {
+                id: string;
+                label: string;
+                instructions: string;
+                required: boolean;
+                allowAbstain: boolean;
+                kind: "boolean";
+                requireRationale?: boolean | undefined;
+                anchors?: {
+                    value: string | number | boolean;
+                    description: string;
+                }[] | undefined;
+            } | {
+                id: string;
+                label: string;
+                instructions: string;
+                required: boolean;
+                allowAbstain: boolean;
+                kind: "text";
+                maximumLength: number;
+                requireRationale?: boolean | undefined;
+                anchors?: {
+                    value: string | number | boolean;
+                    description: string;
+                }[] | undefined;
+                minimumLength?: number | undefined;
+            } | {
+                id: string;
+                label: string;
+                instructions: string;
+                required: boolean;
+                allowAbstain: boolean;
+                kind: "preference";
+                allowTie: boolean;
+                requireRationale?: boolean | undefined;
+                anchors?: {
+                    value: string | number | boolean;
+                    description: string;
+                }[] | undefined;
+                requireStrength?: boolean | undefined;
+            })[];
+        } | undefined;
     })[];
     metadata: Record<string, unknown>;
     contentHash: 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

@@ -124,7 +124,7 @@ export declare const genericToolConformance: {
             entrypoint: string;
             stateful: boolean;
             deterministicSeeds: boolean;
-            lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+            lifecycle: ("step" | "create" | "reset" | "collect" | "destroy")[];
             networkPolicy: "none" | "declared_read_only" | "declared_scoped";
             defaultTimeoutMs: number;
         };
@@ -243,6 +243,80 @@ export declare const genericToolConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             reviewerRole: string;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "category";
+                    options: string[];
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "boolean";
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "text";
+                    maximumLength: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    minimumLength?: number | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "preference";
+                    allowTie: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    requireStrength?: boolean | undefined;
+                })[];
+            } | undefined;
         })[];
         metadata: Record<string, unknown>;
         contentHash: string;
@@ -435,7 +509,7 @@ export declare const marketingPortfolioConformance: {
             entrypoint: string;
             stateful: boolean;
             deterministicSeeds: boolean;
-            lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+            lifecycle: ("step" | "create" | "reset" | "collect" | "destroy")[];
             networkPolicy: "none" | "declared_read_only" | "declared_scoped";
             defaultTimeoutMs: number;
         };
@@ -554,6 +628,80 @@ export declare const marketingPortfolioConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             reviewerRole: string;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "category";
+                    options: string[];
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "boolean";
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "text";
+                    maximumLength: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    minimumLength?: number | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "preference";
+                    allowTie: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    requireStrength?: boolean | undefined;
+                })[];
+            } | undefined;
         })[];
         metadata: Record<string, unknown>;
         contentHash: 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"}