@felspar/sdk 0.0.0-stage → 0.1.1

package/dist/types/draft-hosted-client.d.ts

@@ -0,0 +1,3384 @@
+import { z } from "zod";
+declare const refusalSchema: z.ZodPipe<z.ZodObject<{
+    error: z.ZodString;
+    path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    currentReleaseDigest: z.ZodOptional<z.ZodString>;
+    retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+    issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        path: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<{
+    issues?: {
+        code: string;
+        path: string[];
+    }[] | undefined;
+    fix?: string;
+    error: string;
+    path?: string[] | undefined;
+    currentReleaseDigest?: string | undefined;
+    retryAfterSeconds?: number | undefined;
+}, {
+    error: string;
+    path?: string[] | undefined;
+    currentReleaseDigest?: string | undefined;
+    retryAfterSeconds?: number | undefined;
+    issues?: {
+        code: string;
+        path: string[];
+    }[] | undefined;
+}>>;
+export type FelsparRefusal = z.output<typeof refusalSchema>;
+export declare class FelsparRequestError extends Error {
+    readonly status: number;
+    readonly refusal: FelsparRefusal | null;
+    constructor(options: ErrorOptions & {
+        status: number;
+        refusal: FelsparRefusal | null;
+    });
+}
+export declare function createHostedFelsparClient(configuration: {
+    origin: string;
+    session?: string;
+    agentKey?: string;
+    fetcher?: typeof fetch;
+}): {
+    executeJob: (id: string, value: unknown) => Promise<{
+        status: string;
+        reason: string | null;
+        result: {
+            [x: string]: unknown;
+            executionId: string;
+            releaseId: string;
+            releaseDigest: string;
+            outcome: string | null;
+            scoring: unknown;
+            context: unknown;
+            receipt: unknown;
+        } | null;
+    }>;
+    resolveFacts: (id: string, value: Record<string, unknown>) => Promise<{
+        status: string;
+        reason: string | null;
+        result: {
+            [x: string]: unknown;
+            executionId: string;
+            releaseId: string;
+            releaseDigest: string;
+            outcome: string | null;
+            scoring: unknown;
+            context: unknown;
+            receipt: unknown;
+        } | null;
+    }>;
+    resolveJob: (id: string, value: unknown) => Promise<{
+        status: string;
+        reason: string | null;
+        result: {
+            [x: string]: unknown;
+            executionId: string;
+            releaseId: string;
+            releaseDigest: string;
+            outcome: string | null;
+            scoring: unknown;
+            context: unknown;
+            receipt: unknown;
+        } | null;
+    }>;
+    checkOutput: (job: string, value: unknown) => Promise<{
+        [x: string]: unknown;
+        status: "review_required" | "unavailable" | "pass" | "revise";
+        checkId: string;
+        output: string;
+        findings: Record<string, unknown>[];
+        receipt: {
+            [x: string]: unknown;
+            receiptDigest: string;
+            artifactDigest: string;
+        } | null;
+        decision: {
+            executionId: string;
+            receiptDigest: string;
+        };
+        actionAuthorized: false;
+    }>;
+    readOutputCheck: (job: string, checkId: string) => Promise<{
+        [x: string]: unknown;
+        status: "review_required" | "unavailable" | "pass" | "revise";
+        checkId: string;
+        output: string;
+        findings: Record<string, unknown>[];
+        receipt: {
+            [x: string]: unknown;
+            receiptDigest: string;
+            artifactDigest: string;
+        } | null;
+        decision: {
+            executionId: string;
+            receiptDigest: string;
+        };
+        actionAuthorized: false;
+    }>;
+    submitSource: (value: unknown) => Promise<{
+        id: string;
+        kind: "source" | "evidence" | "proposal" | "result" | "execution" | "release" | "approval";
+        payloadDigest: string;
+        objectKey: string;
+        parentId: string | null;
+        status: "revoked" | "active" | "released";
+        metadata: Record<string, unknown>;
+    }>;
+    submitProposal: (value: unknown) => Promise<{
+        id: string;
+        kind: "source" | "evidence" | "proposal" | "result" | "execution" | "release" | "approval";
+        payloadDigest: string;
+        objectKey: string;
+        parentId: string | null;
+        status: "revoked" | "active" | "released";
+        metadata: Record<string, unknown>;
+    }>;
+    approveProposal: (id: string, value: unknown) => Promise<{
+        id: string;
+        kind: "source" | "evidence" | "proposal" | "result" | "execution" | "release" | "approval";
+        payloadDigest: string;
+        objectKey: string;
+        parentId: string | null;
+        status: "revoked" | "active" | "released";
+        metadata: Record<string, unknown>;
+    }>;
+    releasePack: (id: string, value: unknown) => Promise<{
+        schema: "felspar.application-release.draft/v0";
+        scope: {
+            organizationId: string;
+            environmentId: string;
+            authorityId: string;
+        };
+        releaseId: string;
+        jobId: string;
+        trustDomain: string;
+        materialDigest: string;
+        approvalId: string;
+        approvedMaterialDigest: string;
+        releaseDigest: string;
+        status: "revoked" | "draft" | "released";
+    }>;
+    loadRelease: (id: string) => Promise<{
+        release: {
+            schema: "felspar.application-release.draft/v0";
+            scope: {
+                organizationId: string;
+                environmentId: string;
+                authorityId: string;
+            };
+            releaseId: string;
+            jobId: string;
+            trustDomain: string;
+            materialDigest: string;
+            approvalId: string;
+            approvedMaterialDigest: string;
+            releaseDigest: string;
+            status: "revoked" | "draft" | "released";
+        };
+        material: {
+            discovery: {
+                schema: "felspar.job-discovery.draft/v0";
+                requirements: {
+                    schema: "felspar.requirements-request.draft/v0";
+                    job: string;
+                    trustDomain: string;
+                    maxResponseBytes: number;
+                    route: "normalized";
+                    authority: {
+                        catalog: {
+                            proposal: {
+                                candidateId: string;
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                    contentDigest: string;
+                                };
+                                job: string;
+                                trustDomain: string;
+                                resolutionPolicy: "relative-date-required-types/direct-overrides/v5" | "relational-required-types/direct-overrides/v4" | "scored-required-types/mandatory-gates/v6" | "windowed-required-types/mandatory-gates/v7" | "conditional-required-types/direct-overrides/v3" | "strict-required-types/direct-overrides/v2" | "strict-required-values/direct-overrides/v1";
+                                requirements: {
+                                    definition: {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        allowedValues: string[];
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "boolean";
+                                        };
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "number";
+                                            integer: boolean;
+                                            minimum: number;
+                                            maximum: number;
+                                        };
+                                        unit: string;
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "date";
+                                        };
+                                    };
+                                    evidencePolicy: {
+                                        maxAgeMs: number;
+                                        allowedSourceClasses: string[];
+                                        trustDomain: string;
+                                    };
+                                    requiredWhen?: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[] | undefined;
+                                }[];
+                                allowedOutcomes: string[];
+                                rules: {
+                                    id: string;
+                                    sourceLocator: string;
+                                    contentDigest: string;
+                                    when: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[];
+                                    outcome: string;
+                                    overrides: string[];
+                                    scoreRange?: {
+                                        minimumUnits: number;
+                                        maximumUnits: number;
+                                    } | undefined;
+                                    priority?: number | undefined;
+                                }[];
+                                scoring?: {
+                                    schema: "felspar.scoring.draft/v0";
+                                    scale: 1 | 100 | 10000;
+                                    missingPolicy: "withhold_total";
+                                    inactivePolicy: "exclude_without_redistribution";
+                                    criteria: {
+                                        maximumUnits: number;
+                                        otherwiseUnits: number;
+                                        cases: {
+                                            when: ({
+                                                key: string;
+                                                relativeDate: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                relativeToDecision: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                equals: string | boolean;
+                                            } | {
+                                                key: string;
+                                                oneOf: string[];
+                                            } | {
+                                                key: string;
+                                                compare: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareFact: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareDate: /*elided*/ any;
+                                            })[];
+                                            pointsUnits: number;
+                                            sourceLocator: string;
+                                            contentDigest: string;
+                                            id: string;
+                                        }[];
+                                        sourceLocator: string;
+                                        contentDigest: string;
+                                        id: string;
+                                        activeWhen?: ({
+                                            key: string;
+                                            relativeDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                anchorKey: string;
+                                                offsetDays: number;
+                                                calendar: /*elided*/ any | /*elided*/ any;
+                                            };
+                                        } | {
+                                            key: string;
+                                            relativeToDecision: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                offsetDays: number;
+                                                timeZone: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            equals: string | boolean;
+                                        } | {
+                                            key: string;
+                                            oneOf: string[];
+                                        } | {
+                                            key: string;
+                                            compare: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: number;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareFact: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                key: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: string;
+                                            };
+                                        })[] | undefined;
+                                    }[];
+                                } | undefined;
+                                mandatoryGateRuleIds?: string[] | undefined;
+                            };
+                            bindings: {
+                                key: string;
+                                semanticBundleDigest: string;
+                                evaluatorContractDigest: string;
+                            }[];
+                            materials: {
+                                key: string;
+                                semantics: {
+                                    source: {
+                                        candidate: {
+                                            schema: "felspar.pack-candidate.draft/v0";
+                                            candidateId: string;
+                                            authority: {
+                                                kind: "proposal";
+                                                job: string;
+                                                source: /*elided*/ any;
+                                                definition: /*elided*/ any;
+                                                allowedOutcomes: string[];
+                                                rules: /*elided*/ any[];
+                                            };
+                                        };
+                                        bundle: {
+                                            schema: "felspar.source-text-bundle.draft/v0";
+                                            sources: {
+                                                sourceId: string;
+                                                revision: string;
+                                                text: string;
+                                                offsetUnit: "utf16_code_units";
+                                                passages: /*elided*/ any[];
+                                            }[];
+                                        };
+                                        compositions: {
+                                            schema: "felspar.source-compositions.draft/v0";
+                                            transformContract: "felspar.ordered-source-passage-join/v1";
+                                            candidateDigest: string;
+                                            entries: {
+                                                source: /*elided*/ any;
+                                                locator: string;
+                                                parts: string[];
+                                                separator: "" | "\n" | "\n\n";
+                                            }[];
+                                        };
+                                    };
+                                    proposal: {
+                                        values: {
+                                            value: string;
+                                            definitionLocator: string;
+                                            inclusions: string[];
+                                            exclusions: string[];
+                                            examples: string[];
+                                            edgeCases: string[];
+                                        }[];
+                                        normalization: {
+                                            id: string;
+                                            version: string;
+                                            instructions: string;
+                                        };
+                                    };
+                                };
+                                evaluatorContract: {
+                                    schema: "felspar.evaluator-contract.draft/v0";
+                                    authority: "unapproved";
+                                    id: string;
+                                    version: string;
+                                    semanticDefinitionDigest: string;
+                                    normalizationProposalDigest: string;
+                                    evaluator: {
+                                        provider: string;
+                                        requestedModel: string;
+                                        resolvedModel: string;
+                                    };
+                                    calibration: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    minimumSelectedProbability: number;
+                                    probabilityContract: "closed-distribution-unique-maximum/v1" | "closed-distribution-with-abstention/v1";
+                                    inputContextContract?: "job-entity-time/v1" | undefined;
+                                };
+                            }[];
+                            normalizationContract?: "felspar.conditional-enum-normalization/v1" | undefined;
+                        };
+                        origins: {
+                            schema: "felspar.required-origins.draft/v0";
+                            authorityDigest: string;
+                            entries: {
+                                path: string;
+                                origin: {
+                                    kind: "source_derived";
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    locator: string;
+                                    passageDigest: string;
+                                    admissionRef: string;
+                                } | {
+                                    kind: "owner_decision";
+                                    actorId: string;
+                                    decidedAt: string;
+                                    reviewRef: string;
+                                } | {
+                                    kind: "deterministic_derivation";
+                                    transform: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    inputs: string[];
+                                } | {
+                                    kind: "unsupported_suggestion";
+                                    reason: string;
+                                };
+                            }[];
+                        };
+                        expectedAuthorityDigest: string;
+                        expectedOriginsDigest: string;
+                        bundle: {
+                            schema: "felspar.source-text-bundle.draft/v0";
+                            sources: {
+                                sourceId: string;
+                                revision: string;
+                                text: string;
+                                offsetUnit: "utf16_code_units";
+                                passages: {
+                                    locator: string;
+                                    start: number;
+                                    end: number;
+                                }[];
+                            }[];
+                        };
+                        compositions: {
+                            schema: "felspar.source-compositions.draft/v0";
+                            transformContract: "felspar.ordered-source-passage-join/v1";
+                            candidateDigest: string;
+                            entries: {
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                };
+                                locator: string;
+                                parts: string[];
+                                separator: "" | "\n" | "\n\n";
+                            }[];
+                        };
+                    };
+                } | {
+                    schema: "felspar.requirements-request.draft/v0";
+                    job: string;
+                    trustDomain: string;
+                    maxResponseBytes: number;
+                    route: "supplied";
+                    authority: {
+                        origins: {
+                            schema: "felspar.required-origins.draft/v0";
+                            authorityDigest: string;
+                            entries: {
+                                path: string;
+                                origin: {
+                                    kind: "source_derived";
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    locator: string;
+                                    passageDigest: string;
+                                    admissionRef: string;
+                                } | {
+                                    kind: "owner_decision";
+                                    actorId: string;
+                                    decidedAt: string;
+                                    reviewRef: string;
+                                } | {
+                                    kind: "deterministic_derivation";
+                                    transform: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    inputs: string[];
+                                } | {
+                                    kind: "unsupported_suggestion";
+                                    reason: string;
+                                };
+                            }[];
+                        };
+                        expectedAuthorityDigest: string;
+                        expectedOriginsDigest: string;
+                        bundle: {
+                            schema: "felspar.source-text-bundle.draft/v0";
+                            sources: {
+                                sourceId: string;
+                                revision: string;
+                                text: string;
+                                offsetUnit: "utf16_code_units";
+                                passages: {
+                                    locator: string;
+                                    start: number;
+                                    end: number;
+                                }[];
+                            }[];
+                        };
+                        compositions: {
+                            schema: "felspar.source-compositions.draft/v0";
+                            transformContract: "felspar.ordered-source-passage-join/v1";
+                            candidateDigest: string;
+                            entries: {
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                };
+                                locator: string;
+                                parts: string[];
+                                separator: "" | "\n" | "\n\n";
+                            }[];
+                        };
+                        catalog: {
+                            proposal: {
+                                candidateId: string;
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                    contentDigest: string;
+                                };
+                                job: string;
+                                trustDomain: string;
+                                resolutionPolicy: "relative-date-required-types/direct-overrides/v5" | "relational-required-types/direct-overrides/v4" | "scored-required-types/mandatory-gates/v6" | "windowed-required-types/mandatory-gates/v7" | "conditional-required-types/direct-overrides/v3" | "strict-required-types/direct-overrides/v2" | "strict-required-values/direct-overrides/v1";
+                                requirements: {
+                                    definition: {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        allowedValues: string[];
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "boolean";
+                                        };
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "number";
+                                            integer: boolean;
+                                            minimum: number;
+                                            maximum: number;
+                                        };
+                                        unit: string;
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "date";
+                                        };
+                                    };
+                                    evidencePolicy: {
+                                        maxAgeMs: number;
+                                        allowedSourceClasses: string[];
+                                        trustDomain: string;
+                                    };
+                                    requiredWhen?: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[] | undefined;
+                                }[];
+                                allowedOutcomes: string[];
+                                rules: {
+                                    id: string;
+                                    sourceLocator: string;
+                                    contentDigest: string;
+                                    when: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[];
+                                    outcome: string;
+                                    overrides: string[];
+                                    scoreRange?: {
+                                        minimumUnits: number;
+                                        maximumUnits: number;
+                                    } | undefined;
+                                    priority?: number | undefined;
+                                }[];
+                                scoring?: {
+                                    schema: "felspar.scoring.draft/v0";
+                                    scale: 1 | 100 | 10000;
+                                    missingPolicy: "withhold_total";
+                                    inactivePolicy: "exclude_without_redistribution";
+                                    criteria: {
+                                        maximumUnits: number;
+                                        otherwiseUnits: number;
+                                        cases: {
+                                            when: ({
+                                                key: string;
+                                                relativeDate: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                relativeToDecision: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                equals: string | boolean;
+                                            } | {
+                                                key: string;
+                                                oneOf: string[];
+                                            } | {
+                                                key: string;
+                                                compare: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareFact: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareDate: /*elided*/ any;
+                                            })[];
+                                            pointsUnits: number;
+                                            sourceLocator: string;
+                                            contentDigest: string;
+                                            id: string;
+                                        }[];
+                                        sourceLocator: string;
+                                        contentDigest: string;
+                                        id: string;
+                                        activeWhen?: ({
+                                            key: string;
+                                            relativeDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                anchorKey: string;
+                                                offsetDays: number;
+                                                calendar: /*elided*/ any | /*elided*/ any;
+                                            };
+                                        } | {
+                                            key: string;
+                                            relativeToDecision: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                offsetDays: number;
+                                                timeZone: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            equals: string | boolean;
+                                        } | {
+                                            key: string;
+                                            oneOf: string[];
+                                        } | {
+                                            key: string;
+                                            compare: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: number;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareFact: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                key: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: string;
+                                            };
+                                        })[] | undefined;
+                                    }[];
+                                } | undefined;
+                                mandatoryGateRuleIds?: string[] | undefined;
+                            };
+                            route: {
+                                kind: "supplied_values";
+                                contract: "felspar.declared-scalar-observations/v1";
+                            };
+                        };
+                    };
+                };
+                compilation: {
+                    artifact: {
+                        format: "felspar.json-content-identity/v1";
+                        canonicalJson: string;
+                        contentDigest: string;
+                    };
+                    fixtures: ({
+                        evidence: {
+                            schema: "felspar.evidence-validation.draft/v0";
+                            mode: "new_run";
+                            job: string;
+                            trustDomain: string;
+                            observationChecks: {
+                                schema: "felspar.observation-checks.draft/v0";
+                                scope: {
+                                    schema: "felspar.evidence-scope.draft/v0";
+                                    entityId: string;
+                                    sources: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                        entityId: string;
+                                    }[];
+                                    observations: {
+                                        id: string;
+                                        evidence: {
+                                            sourceId: string;
+                                            revision: string;
+                                            locator: string;
+                                            contentDigest: string;
+                                        };
+                                    }[];
+                                };
+                                evaluationTime: string;
+                                requirement: {
+                                    key: string;
+                                    definitionDigest: string;
+                                    maxAgeMs: number;
+                                };
+                                observations: {
+                                    id: string;
+                                    key: string;
+                                    definitionDigest: string;
+                                    observedAt: string;
+                                }[];
+                            };
+                            allowedSourceClasses: string[];
+                            valueRule: {
+                                type: "number";
+                                integer: boolean;
+                                minimum: number;
+                                maximum: number;
+                            } | {
+                                type: "enum";
+                                values: string[];
+                            } | {
+                                type: "boolean";
+                            } | {
+                                type: "date";
+                            };
+                            collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                            sources: {
+                                reference: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                };
+                                sourceClass: string;
+                                sensitivity: string;
+                            }[];
+                            admissions: {
+                                reference: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                };
+                                purpose: string;
+                                sensitivity: string;
+                                trustDomain: string;
+                                status: "approved" | "revoked";
+                            }[];
+                            normalization: "supplied" | "malformed" | "timeout" | "review_required";
+                            results: {
+                                id: string;
+                                result: {
+                                    status: "supplied";
+                                    value: string | number | boolean;
+                                } | {
+                                    status: "malformed" | "timeout" | "review_required";
+                                };
+                            }[];
+                            unit?: string | undefined;
+                        }[];
+                        id: string;
+                        scope: {
+                            entityId: string;
+                            evaluationTime: string;
+                        };
+                        expected: {
+                            status: "review_required" | "blocked" | "ready" | "gap" | "conflict" | "stale";
+                            outcome: string | null;
+                            selectedRuleIds: string[];
+                            scoring?: {
+                                status: "unresolved" | "ready";
+                                scale: 1 | 100 | 10000;
+                                maximumUnits: number;
+                                totalUnits: number | null;
+                                criteria: {
+                                    criterionId: string;
+                                    status: "matched" | "otherwise" | "inactive" | "unresolved";
+                                    pointsUnits: number | null;
+                                    matchedCaseId: string | null;
+                                }[];
+                            } | undefined;
+                        };
+                    } | {
+                        facts: {
+                            key: string;
+                            value: string | number | boolean;
+                        }[];
+                        id: string;
+                        scope: {
+                            entityId: string;
+                            evaluationTime: string;
+                        };
+                        expected: {
+                            status: "review_required" | "blocked" | "ready" | "gap" | "conflict" | "stale";
+                            outcome: string | null;
+                            selectedRuleIds: string[];
+                            scoring?: {
+                                status: "unresolved" | "ready";
+                                scale: 1 | 100 | 10000;
+                                maximumUnits: number;
+                                totalUnits: number | null;
+                                criteria: {
+                                    criterionId: string;
+                                    status: "matched" | "otherwise" | "inactive" | "unresolved";
+                                    pointsUnits: number | null;
+                                    matchedCaseId: string | null;
+                                }[];
+                            } | undefined;
+                        };
+                    })[];
+                };
+                expectedArtifactDigest: string;
+            };
+            expectedHandoffDigest: string;
+            input: {
+                invocation: {
+                    schema: "felspar.supplied-context.draft/v0";
+                    authority: {
+                        origins: {
+                            schema: "felspar.required-origins.draft/v0";
+                            authorityDigest: string;
+                            entries: {
+                                path: string;
+                                origin: {
+                                    kind: "source_derived";
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    locator: string;
+                                    passageDigest: string;
+                                    admissionRef: string;
+                                } | {
+                                    kind: "owner_decision";
+                                    actorId: string;
+                                    decidedAt: string;
+                                    reviewRef: string;
+                                } | {
+                                    kind: "deterministic_derivation";
+                                    transform: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    inputs: string[];
+                                } | {
+                                    kind: "unsupported_suggestion";
+                                    reason: string;
+                                };
+                            }[];
+                        };
+                        expectedAuthorityDigest: string;
+                        expectedOriginsDigest: string;
+                        bundle: {
+                            schema: "felspar.source-text-bundle.draft/v0";
+                            sources: {
+                                sourceId: string;
+                                revision: string;
+                                text: string;
+                                offsetUnit: "utf16_code_units";
+                                passages: {
+                                    locator: string;
+                                    start: number;
+                                    end: number;
+                                }[];
+                            }[];
+                        };
+                        compositions: {
+                            schema: "felspar.source-compositions.draft/v0";
+                            transformContract: "felspar.ordered-source-passage-join/v1";
+                            candidateDigest: string;
+                            entries: {
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                };
+                                locator: string;
+                                parts: string[];
+                                separator: "" | "\n" | "\n\n";
+                            }[];
+                        };
+                        catalog: {
+                            proposal: {
+                                candidateId: string;
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                    contentDigest: string;
+                                };
+                                job: string;
+                                trustDomain: string;
+                                resolutionPolicy: "relative-date-required-types/direct-overrides/v5" | "relational-required-types/direct-overrides/v4" | "scored-required-types/mandatory-gates/v6" | "windowed-required-types/mandatory-gates/v7" | "conditional-required-types/direct-overrides/v3" | "strict-required-types/direct-overrides/v2" | "strict-required-values/direct-overrides/v1";
+                                requirements: {
+                                    definition: {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        allowedValues: string[];
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "boolean";
+                                        };
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "number";
+                                            integer: boolean;
+                                            minimum: number;
+                                            maximum: number;
+                                        };
+                                        unit: string;
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "date";
+                                        };
+                                    };
+                                    evidencePolicy: {
+                                        maxAgeMs: number;
+                                        allowedSourceClasses: string[];
+                                        trustDomain: string;
+                                    };
+                                    requiredWhen?: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[] | undefined;
+                                }[];
+                                allowedOutcomes: string[];
+                                rules: {
+                                    id: string;
+                                    sourceLocator: string;
+                                    contentDigest: string;
+                                    when: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[];
+                                    outcome: string;
+                                    overrides: string[];
+                                    scoreRange?: {
+                                        minimumUnits: number;
+                                        maximumUnits: number;
+                                    } | undefined;
+                                    priority?: number | undefined;
+                                }[];
+                                scoring?: {
+                                    schema: "felspar.scoring.draft/v0";
+                                    scale: 1 | 100 | 10000;
+                                    missingPolicy: "withhold_total";
+                                    inactivePolicy: "exclude_without_redistribution";
+                                    criteria: {
+                                        maximumUnits: number;
+                                        otherwiseUnits: number;
+                                        cases: {
+                                            when: ({
+                                                key: string;
+                                                relativeDate: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                relativeToDecision: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                equals: string | boolean;
+                                            } | {
+                                                key: string;
+                                                oneOf: string[];
+                                            } | {
+                                                key: string;
+                                                compare: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareFact: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareDate: /*elided*/ any;
+                                            })[];
+                                            pointsUnits: number;
+                                            sourceLocator: string;
+                                            contentDigest: string;
+                                            id: string;
+                                        }[];
+                                        sourceLocator: string;
+                                        contentDigest: string;
+                                        id: string;
+                                        activeWhen?: ({
+                                            key: string;
+                                            relativeDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                anchorKey: string;
+                                                offsetDays: number;
+                                                calendar: /*elided*/ any | /*elided*/ any;
+                                            };
+                                        } | {
+                                            key: string;
+                                            relativeToDecision: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                offsetDays: number;
+                                                timeZone: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            equals: string | boolean;
+                                        } | {
+                                            key: string;
+                                            oneOf: string[];
+                                        } | {
+                                            key: string;
+                                            compare: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: number;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareFact: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                key: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: string;
+                                            };
+                                        })[] | undefined;
+                                    }[];
+                                } | undefined;
+                                mandatoryGateRuleIds?: string[] | undefined;
+                            };
+                            route: {
+                                kind: "supplied_values";
+                                contract: "felspar.declared-scalar-observations/v1";
+                            };
+                        };
+                    };
+                    request: {
+                        job: string;
+                        scope: {
+                            entityId: string;
+                            evaluationTime: string;
+                        };
+                        trustDomain: string;
+                        expectedArtifactDigest: string;
+                    };
+                    compilation: {
+                        artifact: {
+                            format: "felspar.json-content-identity/v1";
+                            canonicalJson: string;
+                            contentDigest: string;
+                        };
+                        fixtures: ({
+                            evidence: {
+                                schema: "felspar.evidence-validation.draft/v0";
+                                mode: "new_run";
+                                job: string;
+                                trustDomain: string;
+                                observationChecks: {
+                                    schema: "felspar.observation-checks.draft/v0";
+                                    scope: {
+                                        schema: "felspar.evidence-scope.draft/v0";
+                                        entityId: string;
+                                        sources: {
+                                            sourceId: string;
+                                            revision: string;
+                                            locator: string;
+                                            contentDigest: string;
+                                            entityId: string;
+                                        }[];
+                                        observations: {
+                                            id: string;
+                                            evidence: {
+                                                sourceId: string;
+                                                revision: string;
+                                                locator: string;
+                                                contentDigest: string;
+                                            };
+                                        }[];
+                                    };
+                                    evaluationTime: string;
+                                    requirement: {
+                                        key: string;
+                                        definitionDigest: string;
+                                        maxAgeMs: number;
+                                    };
+                                    observations: {
+                                        id: string;
+                                        key: string;
+                                        definitionDigest: string;
+                                        observedAt: string;
+                                    }[];
+                                };
+                                allowedSourceClasses: string[];
+                                valueRule: {
+                                    type: "number";
+                                    integer: boolean;
+                                    minimum: number;
+                                    maximum: number;
+                                } | {
+                                    type: "enum";
+                                    values: string[];
+                                } | {
+                                    type: "boolean";
+                                } | {
+                                    type: "date";
+                                };
+                                collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                                sources: {
+                                    reference: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                    };
+                                    sourceClass: string;
+                                    sensitivity: string;
+                                }[];
+                                admissions: {
+                                    reference: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                    };
+                                    purpose: string;
+                                    sensitivity: string;
+                                    trustDomain: string;
+                                    status: "approved" | "revoked";
+                                }[];
+                                normalization: "supplied" | "malformed" | "timeout" | "review_required";
+                                results: {
+                                    id: string;
+                                    result: {
+                                        status: "supplied";
+                                        value: string | number | boolean;
+                                    } | {
+                                        status: "malformed" | "timeout" | "review_required";
+                                    };
+                                }[];
+                                unit?: string | undefined;
+                            }[];
+                            id: string;
+                            scope: {
+                                entityId: string;
+                                evaluationTime: string;
+                            };
+                            expected: {
+                                status: "review_required" | "blocked" | "ready" | "gap" | "conflict" | "stale";
+                                outcome: string | null;
+                                selectedRuleIds: string[];
+                                scoring?: {
+                                    status: "unresolved" | "ready";
+                                    scale: 1 | 100 | 10000;
+                                    maximumUnits: number;
+                                    totalUnits: number | null;
+                                    criteria: {
+                                        criterionId: string;
+                                        status: "matched" | "otherwise" | "inactive" | "unresolved";
+                                        pointsUnits: number | null;
+                                        matchedCaseId: string | null;
+                                    }[];
+                                } | undefined;
+                            };
+                        } | {
+                            facts: {
+                                key: string;
+                                value: string | number | boolean;
+                            }[];
+                            id: string;
+                            scope: {
+                                entityId: string;
+                                evaluationTime: string;
+                            };
+                            expected: {
+                                status: "review_required" | "blocked" | "ready" | "gap" | "conflict" | "stale";
+                                outcome: string | null;
+                                selectedRuleIds: string[];
+                                scoring?: {
+                                    status: "unresolved" | "ready";
+                                    scale: 1 | 100 | 10000;
+                                    maximumUnits: number;
+                                    totalUnits: number | null;
+                                    criteria: {
+                                        criterionId: string;
+                                        status: "matched" | "otherwise" | "inactive" | "unresolved";
+                                        pointsUnits: number | null;
+                                        matchedCaseId: string | null;
+                                    }[];
+                                } | undefined;
+                            };
+                        })[];
+                    };
+                    plan: {
+                        schema: "felspar.context-selection.draft/v0" | "felspar.context-selection.draft/v1" | "felspar.context-selection.draft/v2";
+                        authority: "unapproved";
+                        artifactDigest: string;
+                        job: string;
+                        trustDomain: string;
+                        outputSurface: string;
+                        entries: {
+                            id: string;
+                            primitive: "gaps" | "actors" | "decision_criteria" | "source_signals" | "needs_and_requirements" | "evidence_and_proof" | "boundaries" | "output_contracts" | "routing_jobs" | "evaluations";
+                            body: string;
+                            source: {
+                                sourceId: string;
+                                revision: string;
+                                locator: string;
+                                contentDigest: string;
+                            };
+                            dependencies: string[];
+                            conflictsWith: string[];
+                        }[];
+                        requiredIds: string[];
+                        budget: {
+                            maxEntries: number;
+                            maxBytes: number;
+                        };
+                        groups: {
+                            id: string;
+                            min: number;
+                            max: number;
+                            candidates: {
+                                entryId: string;
+                                outcomes: string[];
+                                when: {
+                                    key: string;
+                                    equals: string;
+                                }[];
+                                priority: number;
+                            }[];
+                        }[];
+                        evaluationValidation?: {
+                            contract: "felspar.required-evaluations/v1";
+                            recipes: {
+                                entryId: string;
+                                expectedRecipeDigest: string;
+                            }[];
+                            maxRequests: number;
+                            maxTotalBytes: number;
+                        } | undefined;
+                        outputValidation?: {
+                            contract: "felspar.structured-output-preparation/v1";
+                            entryId: string;
+                            expectedContractDigest: string;
+                        } | undefined;
+                        unresolvedGuidanceEntryId?: string | undefined;
+                        attempts?: {
+                            max: number;
+                            withProgress: number;
+                        } | undefined;
+                    };
+                    expectedPlanDigest: string;
+                    requestedSurface: string;
+                    contextOrigins: {
+                        bundle: {
+                            schema: "felspar.source-text-bundle.draft/v0";
+                            sources: {
+                                sourceId: string;
+                                revision: string;
+                                text: string;
+                                offsetUnit: "utf16_code_units";
+                                passages: {
+                                    locator: string;
+                                    start: number;
+                                    end: number;
+                                }[];
+                            }[];
+                        };
+                        compositions: {
+                            schema: "felspar.source-compositions.draft/v0";
+                            transformContract: "felspar.ordered-source-passage-join/v1";
+                            candidateDigest: string;
+                            entries: {
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                };
+                                locator: string;
+                                parts: string[];
+                                separator: "" | "\n" | "\n\n";
+                            }[];
+                        };
+                        origins: {
+                            schema: "felspar.context-origins.draft/v0";
+                            planDigest: string;
+                            entries: {
+                                entryId: string;
+                                origin: {
+                                    kind: "source_derived";
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    locator: string;
+                                    passageDigest: string;
+                                    admissionRef: string;
+                                } | {
+                                    kind: "owner_decision";
+                                    actorId: string;
+                                    decidedAt: string;
+                                    reviewRef: string;
+                                } | {
+                                    kind: "deterministic_derivation";
+                                    transform: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    inputs: string[];
+                                } | {
+                                    kind: "unsupported_suggestion";
+                                    reason: string;
+                                };
+                            }[];
+                        };
+                    };
+                };
+                manifest: {
+                    schema: "felspar.typed-interpretation-manifest.draft/v0";
+                    authority: "unapproved";
+                    authorityDigest: string;
+                    recipes: ({
+                        kind: "scalar";
+                        definitionDigest: string;
+                        id: string;
+                        version: string;
+                        instructions: string;
+                        evaluator: {
+                            provider: string;
+                            requestedModel: string;
+                            resolvedModel: string;
+                        };
+                        calibration: {
+                            id: string;
+                            version: string;
+                            contentDigest: string;
+                        };
+                        confidenceContract: "candidate-selected-probability/v1" | "declared-scalar-confidence/v1";
+                        minimumConfidence: number;
+                        key: string;
+                        parser?: {
+                            version: "iso-currency-decimal/v1";
+                            currency: string;
+                        } | {
+                            version: "iso-calendar-date/v1";
+                        } | undefined;
+                        reader?: {
+                            version: "felspar.exact-number/v2";
+                            unit: {
+                                kind: "currency";
+                                code: string;
+                            } | {
+                                kind: "percent";
+                            } | {
+                                kind: "count";
+                                words: string[];
+                            };
+                            numberStyle: "1,234.56" | "1.234,56" | "1 234,56" | "1'234.56";
+                        } | {
+                            version: "felspar.exact-date/v2";
+                            dateOrder: "unstated" | "month-first" | "day-first";
+                        } | undefined;
+                    } | {
+                        kind: "enum";
+                        semanticBundleDigest: string;
+                        evaluatorContractDigest: string;
+                        key: string;
+                    })[];
+                };
+                expectedManifestDigest: string;
+                packets: ({
+                    key: string;
+                    kind: "scalar";
+                    evidence: {
+                        schema: "felspar.evidence-validation.draft/v0";
+                        mode: "new_run";
+                        job: string;
+                        trustDomain: string;
+                        observationChecks: {
+                            schema: "felspar.observation-checks.draft/v0";
+                            scope: {
+                                schema: "felspar.evidence-scope.draft/v0";
+                                entityId: string;
+                                sources: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                    entityId: string;
+                                }[];
+                                observations: {
+                                    id: string;
+                                    evidence: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                    };
+                                }[];
+                            };
+                            evaluationTime: string;
+                            requirement: {
+                                key: string;
+                                definitionDigest: string;
+                                maxAgeMs: number;
+                            };
+                            observations: {
+                                id: string;
+                                key: string;
+                                definitionDigest: string;
+                                observedAt: string;
+                            }[];
+                        };
+                        allowedSourceClasses: string[];
+                        valueRule: {
+                            type: "number";
+                            integer: boolean;
+                            minimum: number;
+                            maximum: number;
+                        } | {
+                            type: "enum";
+                            values: string[];
+                        } | {
+                            type: "boolean";
+                        } | {
+                            type: "date";
+                        };
+                        collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                        sources: {
+                            reference: {
+                                sourceId: string;
+                                revision: string;
+                                locator: string;
+                                contentDigest: string;
+                            };
+                            sourceClass: string;
+                            sensitivity: string;
+                        }[];
+                        admissions: {
+                            reference: {
+                                sourceId: string;
+                                revision: string;
+                                locator: string;
+                                contentDigest: string;
+                            };
+                            purpose: string;
+                            sensitivity: string;
+                            trustDomain: string;
+                            status: "approved" | "revoked";
+                        }[];
+                        unit?: string | undefined;
+                    };
+                } | {
+                    key: string;
+                    kind: "enum";
+                    input: {
+                        schema: "felspar.normalized-evidence.draft/v0";
+                        evidence: {
+                            schema: "felspar.evidence-validation.draft/v0";
+                            mode: "new_run";
+                            job: string;
+                            trustDomain: string;
+                            observationChecks: {
+                                schema: "felspar.observation-checks.draft/v0";
+                                scope: {
+                                    schema: "felspar.evidence-scope.draft/v0";
+                                    entityId: string;
+                                    sources: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                        entityId: string;
+                                    }[];
+                                    observations: {
+                                        id: string;
+                                        evidence: {
+                                            sourceId: string;
+                                            revision: string;
+                                            locator: string;
+                                            contentDigest: string;
+                                        };
+                                    }[];
+                                };
+                                evaluationTime: string;
+                                requirement: {
+                                    key: string;
+                                    definitionDigest: string;
+                                    maxAgeMs: number;
+                                };
+                                observations: {
+                                    id: string;
+                                    key: string;
+                                    definitionDigest: string;
+                                    observedAt: string;
+                                }[];
+                            };
+                            allowedSourceClasses: string[];
+                            collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                            sources: {
+                                reference: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                };
+                                sourceClass: string;
+                                sensitivity: string;
+                            }[];
+                            admissions: {
+                                reference: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                };
+                                purpose: string;
+                                sensitivity: string;
+                                trustDomain: string;
+                                status: "approved" | "revoked";
+                            }[];
+                        };
+                        proposal: {
+                            candidate: {
+                                schema: "felspar.pack-candidate.draft/v0";
+                                candidateId: string;
+                                authority: {
+                                    kind: "proposal";
+                                    job: string;
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    definition: {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        allowedValues: string[];
+                                    };
+                                    allowedOutcomes: string[];
+                                    rules: {
+                                        id: string;
+                                        sourceLocator: string;
+                                        contentDigest: string;
+                                        when: {
+                                            key: string;
+                                            equals: string;
+                                        };
+                                        outcome: string;
+                                    }[];
+                                };
+                            };
+                            evidencePolicy: {
+                                maxAgeMs: number;
+                                allowedSourceClasses: string[];
+                                trustDomain: string;
+                            };
+                            resolutionPolicy: "strict-single-value/v1";
+                        };
+                        semantics: {
+                            source: {
+                                candidate: {
+                                    schema: "felspar.pack-candidate.draft/v0";
+                                    candidateId: string;
+                                    authority: {
+                                        kind: "proposal";
+                                        job: string;
+                                        source: {
+                                            sourceId: string;
+                                            revision: string;
+                                            contentDigest: string;
+                                        };
+                                        definition: {
+                                            key: string;
+                                            contentDigest: string;
+                                            sourceLocator: string;
+                                            allowedValues: string[];
+                                        };
+                                        allowedOutcomes: string[];
+                                        rules: {
+                                            id: string;
+                                            sourceLocator: string;
+                                            contentDigest: string;
+                                            when: {
+                                                key: string;
+                                                equals: string;
+                                            };
+                                            outcome: string;
+                                        }[];
+                                    };
+                                };
+                                bundle: {
+                                    schema: "felspar.source-text-bundle.draft/v0";
+                                    sources: {
+                                        sourceId: string;
+                                        revision: string;
+                                        text: string;
+                                        offsetUnit: "utf16_code_units";
+                                        passages: {
+                                            locator: string;
+                                            start: number;
+                                            end: number;
+                                        }[];
+                                    }[];
+                                };
+                                compositions: {
+                                    schema: "felspar.source-compositions.draft/v0";
+                                    transformContract: "felspar.ordered-source-passage-join/v1";
+                                    candidateDigest: string;
+                                    entries: {
+                                        source: {
+                                            sourceId: string;
+                                            revision: string;
+                                        };
+                                        locator: string;
+                                        parts: string[];
+                                        separator: "" | "\n" | "\n\n";
+                                    }[];
+                                };
+                            };
+                            proposal: {
+                                values: {
+                                    value: string;
+                                    definitionLocator: string;
+                                    inclusions: string[];
+                                    exclusions: string[];
+                                    examples: string[];
+                                    edgeCases: string[];
+                                }[];
+                                normalization: {
+                                    id: string;
+                                    version: string;
+                                    instructions: string;
+                                };
+                            };
+                        };
+                        expectedSemanticBundleDigest: string;
+                        evaluatorContract: {
+                            schema: "felspar.evaluator-contract.draft/v0";
+                            authority: "unapproved";
+                            id: string;
+                            version: string;
+                            semanticDefinitionDigest: string;
+                            normalizationProposalDigest: string;
+                            evaluator: {
+                                provider: string;
+                                requestedModel: string;
+                                resolvedModel: string;
+                            };
+                            calibration: {
+                                id: string;
+                                version: string;
+                                contentDigest: string;
+                            };
+                            minimumSelectedProbability: number;
+                            probabilityContract: "closed-distribution-unique-maximum/v1" | "closed-distribution-with-abstention/v1";
+                            inputContextContract?: "job-entity-time/v1" | undefined;
+                        };
+                        expectedEvaluatorContractDigest: string;
+                        answerType?: "boolean" | undefined;
+                    };
+                })[];
+                passages: {
+                    reference: {
+                        sourceId: string;
+                        revision: string;
+                        locator: string;
+                        contentDigest: string;
+                    };
+                    text: string;
+                }[];
+                schema: "felspar.evaluation-requests.draft/v1";
+                limits: {
+                    maxQuestions: number;
+                    maxRequestBytes: number;
+                    maxResponseBytes: number;
+                    maxRounds: number;
+                    maxTotalQuestions: number;
+                    maxTotalRequestBytes: number;
+                    maxTotalResponseBytes: number;
+                };
+            };
+        } | {
+            schema: "felspar.application-job-material.draft/v2";
+            discovery: {
+                schema: "felspar.job-discovery-reference.draft/v1";
+                route: "supplied" | "normalized";
+                job: string;
+                trustDomain: string;
+                maxResponseBytes: number;
+                expectedArtifactDigest: string;
+            };
+            expectedHandoffDigest: string;
+            input: {
+                invocation: {
+                    schema: "felspar.supplied-context.draft/v0";
+                    authority: {
+                        origins: {
+                            schema: "felspar.required-origins.draft/v0";
+                            authorityDigest: string;
+                            entries: {
+                                path: string;
+                                origin: {
+                                    kind: "source_derived";
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    locator: string;
+                                    passageDigest: string;
+                                    admissionRef: string;
+                                } | {
+                                    kind: "owner_decision";
+                                    actorId: string;
+                                    decidedAt: string;
+                                    reviewRef: string;
+                                } | {
+                                    kind: "deterministic_derivation";
+                                    transform: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    inputs: string[];
+                                } | {
+                                    kind: "unsupported_suggestion";
+                                    reason: string;
+                                };
+                            }[];
+                        };
+                        expectedAuthorityDigest: string;
+                        expectedOriginsDigest: string;
+                        bundle: {
+                            schema: "felspar.source-text-bundle.draft/v0";
+                            sources: {
+                                sourceId: string;
+                                revision: string;
+                                text: string;
+                                offsetUnit: "utf16_code_units";
+                                passages: {
+                                    locator: string;
+                                    start: number;
+                                    end: number;
+                                }[];
+                            }[];
+                        };
+                        compositions: {
+                            schema: "felspar.source-compositions.draft/v0";
+                            transformContract: "felspar.ordered-source-passage-join/v1";
+                            candidateDigest: string;
+                            entries: {
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                };
+                                locator: string;
+                                parts: string[];
+                                separator: "" | "\n" | "\n\n";
+                            }[];
+                        };
+                        catalog: {
+                            proposal: {
+                                candidateId: string;
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                    contentDigest: string;
+                                };
+                                job: string;
+                                trustDomain: string;
+                                resolutionPolicy: "relative-date-required-types/direct-overrides/v5" | "relational-required-types/direct-overrides/v4" | "scored-required-types/mandatory-gates/v6" | "windowed-required-types/mandatory-gates/v7" | "conditional-required-types/direct-overrides/v3" | "strict-required-types/direct-overrides/v2" | "strict-required-values/direct-overrides/v1";
+                                requirements: {
+                                    definition: {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        allowedValues: string[];
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "boolean";
+                                        };
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "number";
+                                            integer: boolean;
+                                            minimum: number;
+                                            maximum: number;
+                                        };
+                                        unit: string;
+                                    } | {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        valueRule: {
+                                            type: "date";
+                                        };
+                                    };
+                                    evidencePolicy: {
+                                        maxAgeMs: number;
+                                        allowedSourceClasses: string[];
+                                        trustDomain: string;
+                                    };
+                                    requiredWhen?: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[] | undefined;
+                                }[];
+                                allowedOutcomes: string[];
+                                rules: {
+                                    id: string;
+                                    sourceLocator: string;
+                                    contentDigest: string;
+                                    when: ({
+                                        key: string;
+                                        relativeDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            anchorKey: string;
+                                            offsetDays: number;
+                                            calendar: {
+                                                kind: "business_days";
+                                                id: string;
+                                                version: string;
+                                                validFrom: string;
+                                                validThrough: string;
+                                                workingWeekdays: number[];
+                                                holidays: string[];
+                                            } | {
+                                                kind: "calendar_days";
+                                            };
+                                        };
+                                    } | {
+                                        key: string;
+                                        relativeToDecision: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            offsetDays: number;
+                                            timeZone: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        equals: string | boolean;
+                                    } | {
+                                        key: string;
+                                        oneOf: string[];
+                                    } | {
+                                        key: string;
+                                        compare: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: number;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareFact: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            key: string;
+                                        };
+                                    } | {
+                                        key: string;
+                                        compareDate: {
+                                            operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                            value: string;
+                                        };
+                                    })[];
+                                    outcome: string;
+                                    overrides: string[];
+                                    scoreRange?: {
+                                        minimumUnits: number;
+                                        maximumUnits: number;
+                                    } | undefined;
+                                    priority?: number | undefined;
+                                }[];
+                                scoring?: {
+                                    schema: "felspar.scoring.draft/v0";
+                                    scale: 1 | 100 | 10000;
+                                    missingPolicy: "withhold_total";
+                                    inactivePolicy: "exclude_without_redistribution";
+                                    criteria: {
+                                        maximumUnits: number;
+                                        otherwiseUnits: number;
+                                        cases: {
+                                            when: ({
+                                                key: string;
+                                                relativeDate: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                relativeToDecision: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                equals: string | boolean;
+                                            } | {
+                                                key: string;
+                                                oneOf: string[];
+                                            } | {
+                                                key: string;
+                                                compare: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareFact: /*elided*/ any;
+                                            } | {
+                                                key: string;
+                                                compareDate: /*elided*/ any;
+                                            })[];
+                                            pointsUnits: number;
+                                            sourceLocator: string;
+                                            contentDigest: string;
+                                            id: string;
+                                        }[];
+                                        sourceLocator: string;
+                                        contentDigest: string;
+                                        id: string;
+                                        activeWhen?: ({
+                                            key: string;
+                                            relativeDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                anchorKey: string;
+                                                offsetDays: number;
+                                                calendar: /*elided*/ any | /*elided*/ any;
+                                            };
+                                        } | {
+                                            key: string;
+                                            relativeToDecision: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                offsetDays: number;
+                                                timeZone: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            equals: string | boolean;
+                                        } | {
+                                            key: string;
+                                            oneOf: string[];
+                                        } | {
+                                            key: string;
+                                            compare: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: number;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareFact: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                key: string;
+                                            };
+                                        } | {
+                                            key: string;
+                                            compareDate: {
+                                                operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                                                value: string;
+                                            };
+                                        })[] | undefined;
+                                    }[];
+                                } | undefined;
+                                mandatoryGateRuleIds?: string[] | undefined;
+                            };
+                            route: {
+                                kind: "supplied_values";
+                                contract: "felspar.declared-scalar-observations/v1";
+                            };
+                        };
+                    };
+                    request: {
+                        job: string;
+                        scope: {
+                            entityId: string;
+                            evaluationTime: string;
+                        };
+                        trustDomain: string;
+                        expectedArtifactDigest: string;
+                    };
+                    compilation: {
+                        artifact: {
+                            format: "felspar.json-content-identity/v1";
+                            canonicalJson: string;
+                            contentDigest: string;
+                        };
+                        fixtures: ({
+                            evidence: {
+                                schema: "felspar.evidence-validation.draft/v0";
+                                mode: "new_run";
+                                job: string;
+                                trustDomain: string;
+                                observationChecks: {
+                                    schema: "felspar.observation-checks.draft/v0";
+                                    scope: {
+                                        schema: "felspar.evidence-scope.draft/v0";
+                                        entityId: string;
+                                        sources: {
+                                            sourceId: string;
+                                            revision: string;
+                                            locator: string;
+                                            contentDigest: string;
+                                            entityId: string;
+                                        }[];
+                                        observations: {
+                                            id: string;
+                                            evidence: {
+                                                sourceId: string;
+                                                revision: string;
+                                                locator: string;
+                                                contentDigest: string;
+                                            };
+                                        }[];
+                                    };
+                                    evaluationTime: string;
+                                    requirement: {
+                                        key: string;
+                                        definitionDigest: string;
+                                        maxAgeMs: number;
+                                    };
+                                    observations: {
+                                        id: string;
+                                        key: string;
+                                        definitionDigest: string;
+                                        observedAt: string;
+                                    }[];
+                                };
+                                allowedSourceClasses: string[];
+                                valueRule: {
+                                    type: "number";
+                                    integer: boolean;
+                                    minimum: number;
+                                    maximum: number;
+                                } | {
+                                    type: "enum";
+                                    values: string[];
+                                } | {
+                                    type: "boolean";
+                                } | {
+                                    type: "date";
+                                };
+                                collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                                sources: {
+                                    reference: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                    };
+                                    sourceClass: string;
+                                    sensitivity: string;
+                                }[];
+                                admissions: {
+                                    reference: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                    };
+                                    purpose: string;
+                                    sensitivity: string;
+                                    trustDomain: string;
+                                    status: "approved" | "revoked";
+                                }[];
+                                normalization: "supplied" | "malformed" | "timeout" | "review_required";
+                                results: {
+                                    id: string;
+                                    result: {
+                                        status: "supplied";
+                                        value: string | number | boolean;
+                                    } | {
+                                        status: "malformed" | "timeout" | "review_required";
+                                    };
+                                }[];
+                                unit?: string | undefined;
+                            }[];
+                            id: string;
+                            scope: {
+                                entityId: string;
+                                evaluationTime: string;
+                            };
+                            expected: {
+                                status: "review_required" | "blocked" | "ready" | "gap" | "conflict" | "stale";
+                                outcome: string | null;
+                                selectedRuleIds: string[];
+                                scoring?: {
+                                    status: "unresolved" | "ready";
+                                    scale: 1 | 100 | 10000;
+                                    maximumUnits: number;
+                                    totalUnits: number | null;
+                                    criteria: {
+                                        criterionId: string;
+                                        status: "matched" | "otherwise" | "inactive" | "unresolved";
+                                        pointsUnits: number | null;
+                                        matchedCaseId: string | null;
+                                    }[];
+                                } | undefined;
+                            };
+                        } | {
+                            facts: {
+                                key: string;
+                                value: string | number | boolean;
+                            }[];
+                            id: string;
+                            scope: {
+                                entityId: string;
+                                evaluationTime: string;
+                            };
+                            expected: {
+                                status: "review_required" | "blocked" | "ready" | "gap" | "conflict" | "stale";
+                                outcome: string | null;
+                                selectedRuleIds: string[];
+                                scoring?: {
+                                    status: "unresolved" | "ready";
+                                    scale: 1 | 100 | 10000;
+                                    maximumUnits: number;
+                                    totalUnits: number | null;
+                                    criteria: {
+                                        criterionId: string;
+                                        status: "matched" | "otherwise" | "inactive" | "unresolved";
+                                        pointsUnits: number | null;
+                                        matchedCaseId: string | null;
+                                    }[];
+                                } | undefined;
+                            };
+                        })[];
+                    };
+                    plan: {
+                        schema: "felspar.context-selection.draft/v0" | "felspar.context-selection.draft/v1" | "felspar.context-selection.draft/v2";
+                        authority: "unapproved";
+                        artifactDigest: string;
+                        job: string;
+                        trustDomain: string;
+                        outputSurface: string;
+                        entries: {
+                            id: string;
+                            primitive: "gaps" | "actors" | "decision_criteria" | "source_signals" | "needs_and_requirements" | "evidence_and_proof" | "boundaries" | "output_contracts" | "routing_jobs" | "evaluations";
+                            body: string;
+                            source: {
+                                sourceId: string;
+                                revision: string;
+                                locator: string;
+                                contentDigest: string;
+                            };
+                            dependencies: string[];
+                            conflictsWith: string[];
+                        }[];
+                        requiredIds: string[];
+                        budget: {
+                            maxEntries: number;
+                            maxBytes: number;
+                        };
+                        groups: {
+                            id: string;
+                            min: number;
+                            max: number;
+                            candidates: {
+                                entryId: string;
+                                outcomes: string[];
+                                when: {
+                                    key: string;
+                                    equals: string;
+                                }[];
+                                priority: number;
+                            }[];
+                        }[];
+                        evaluationValidation?: {
+                            contract: "felspar.required-evaluations/v1";
+                            recipes: {
+                                entryId: string;
+                                expectedRecipeDigest: string;
+                            }[];
+                            maxRequests: number;
+                            maxTotalBytes: number;
+                        } | undefined;
+                        outputValidation?: {
+                            contract: "felspar.structured-output-preparation/v1";
+                            entryId: string;
+                            expectedContractDigest: string;
+                        } | undefined;
+                        unresolvedGuidanceEntryId?: string | undefined;
+                        attempts?: {
+                            max: number;
+                            withProgress: number;
+                        } | undefined;
+                    };
+                    expectedPlanDigest: string;
+                    requestedSurface: string;
+                    contextOrigins: {
+                        bundle: {
+                            schema: "felspar.source-text-bundle.draft/v0";
+                            sources: {
+                                sourceId: string;
+                                revision: string;
+                                text: string;
+                                offsetUnit: "utf16_code_units";
+                                passages: {
+                                    locator: string;
+                                    start: number;
+                                    end: number;
+                                }[];
+                            }[];
+                        };
+                        compositions: {
+                            schema: "felspar.source-compositions.draft/v0";
+                            transformContract: "felspar.ordered-source-passage-join/v1";
+                            candidateDigest: string;
+                            entries: {
+                                source: {
+                                    sourceId: string;
+                                    revision: string;
+                                };
+                                locator: string;
+                                parts: string[];
+                                separator: "" | "\n" | "\n\n";
+                            }[];
+                        };
+                        origins: {
+                            schema: "felspar.context-origins.draft/v0";
+                            planDigest: string;
+                            entries: {
+                                entryId: string;
+                                origin: {
+                                    kind: "source_derived";
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    locator: string;
+                                    passageDigest: string;
+                                    admissionRef: string;
+                                } | {
+                                    kind: "owner_decision";
+                                    actorId: string;
+                                    decidedAt: string;
+                                    reviewRef: string;
+                                } | {
+                                    kind: "deterministic_derivation";
+                                    transform: {
+                                        id: string;
+                                        version: string;
+                                        contentDigest: string;
+                                    };
+                                    inputs: string[];
+                                } | {
+                                    kind: "unsupported_suggestion";
+                                    reason: string;
+                                };
+                            }[];
+                        };
+                    };
+                };
+                manifest: {
+                    schema: "felspar.typed-interpretation-manifest.draft/v0";
+                    authority: "unapproved";
+                    authorityDigest: string;
+                    recipes: ({
+                        kind: "scalar";
+                        definitionDigest: string;
+                        id: string;
+                        version: string;
+                        instructions: string;
+                        evaluator: {
+                            provider: string;
+                            requestedModel: string;
+                            resolvedModel: string;
+                        };
+                        calibration: {
+                            id: string;
+                            version: string;
+                            contentDigest: string;
+                        };
+                        confidenceContract: "candidate-selected-probability/v1" | "declared-scalar-confidence/v1";
+                        minimumConfidence: number;
+                        key: string;
+                        parser?: {
+                            version: "iso-currency-decimal/v1";
+                            currency: string;
+                        } | {
+                            version: "iso-calendar-date/v1";
+                        } | undefined;
+                        reader?: {
+                            version: "felspar.exact-number/v2";
+                            unit: {
+                                kind: "currency";
+                                code: string;
+                            } | {
+                                kind: "percent";
+                            } | {
+                                kind: "count";
+                                words: string[];
+                            };
+                            numberStyle: "1,234.56" | "1.234,56" | "1 234,56" | "1'234.56";
+                        } | {
+                            version: "felspar.exact-date/v2";
+                            dateOrder: "unstated" | "month-first" | "day-first";
+                        } | undefined;
+                    } | {
+                        kind: "enum";
+                        semanticBundleDigest: string;
+                        evaluatorContractDigest: string;
+                        key: string;
+                    })[];
+                };
+                expectedManifestDigest: string;
+                packets: ({
+                    key: string;
+                    kind: "scalar";
+                    evidence: {
+                        schema: "felspar.evidence-validation.draft/v0";
+                        mode: "new_run";
+                        job: string;
+                        trustDomain: string;
+                        observationChecks: {
+                            schema: "felspar.observation-checks.draft/v0";
+                            scope: {
+                                schema: "felspar.evidence-scope.draft/v0";
+                                entityId: string;
+                                sources: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                    entityId: string;
+                                }[];
+                                observations: {
+                                    id: string;
+                                    evidence: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                    };
+                                }[];
+                            };
+                            evaluationTime: string;
+                            requirement: {
+                                key: string;
+                                definitionDigest: string;
+                                maxAgeMs: number;
+                            };
+                            observations: {
+                                id: string;
+                                key: string;
+                                definitionDigest: string;
+                                observedAt: string;
+                            }[];
+                        };
+                        allowedSourceClasses: string[];
+                        valueRule: {
+                            type: "number";
+                            integer: boolean;
+                            minimum: number;
+                            maximum: number;
+                        } | {
+                            type: "enum";
+                            values: string[];
+                        } | {
+                            type: "boolean";
+                        } | {
+                            type: "date";
+                        };
+                        collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                        sources: {
+                            reference: {
+                                sourceId: string;
+                                revision: string;
+                                locator: string;
+                                contentDigest: string;
+                            };
+                            sourceClass: string;
+                            sensitivity: string;
+                        }[];
+                        admissions: {
+                            reference: {
+                                sourceId: string;
+                                revision: string;
+                                locator: string;
+                                contentDigest: string;
+                            };
+                            purpose: string;
+                            sensitivity: string;
+                            trustDomain: string;
+                            status: "approved" | "revoked";
+                        }[];
+                        unit?: string | undefined;
+                    };
+                } | {
+                    key: string;
+                    kind: "enum";
+                    input: {
+                        schema: "felspar.normalized-evidence.draft/v0";
+                        evidence: {
+                            schema: "felspar.evidence-validation.draft/v0";
+                            mode: "new_run";
+                            job: string;
+                            trustDomain: string;
+                            observationChecks: {
+                                schema: "felspar.observation-checks.draft/v0";
+                                scope: {
+                                    schema: "felspar.evidence-scope.draft/v0";
+                                    entityId: string;
+                                    sources: {
+                                        sourceId: string;
+                                        revision: string;
+                                        locator: string;
+                                        contentDigest: string;
+                                        entityId: string;
+                                    }[];
+                                    observations: {
+                                        id: string;
+                                        evidence: {
+                                            sourceId: string;
+                                            revision: string;
+                                            locator: string;
+                                            contentDigest: string;
+                                        };
+                                    }[];
+                                };
+                                evaluationTime: string;
+                                requirement: {
+                                    key: string;
+                                    definitionDigest: string;
+                                    maxAgeMs: number;
+                                };
+                                observations: {
+                                    id: string;
+                                    key: string;
+                                    definitionDigest: string;
+                                    observedAt: string;
+                                }[];
+                            };
+                            allowedSourceClasses: string[];
+                            collection: "error" | "observed" | "not_found" | "blocked" | "not_applicable" | "unattempted";
+                            sources: {
+                                reference: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                };
+                                sourceClass: string;
+                                sensitivity: string;
+                            }[];
+                            admissions: {
+                                reference: {
+                                    sourceId: string;
+                                    revision: string;
+                                    locator: string;
+                                    contentDigest: string;
+                                };
+                                purpose: string;
+                                sensitivity: string;
+                                trustDomain: string;
+                                status: "approved" | "revoked";
+                            }[];
+                        };
+                        proposal: {
+                            candidate: {
+                                schema: "felspar.pack-candidate.draft/v0";
+                                candidateId: string;
+                                authority: {
+                                    kind: "proposal";
+                                    job: string;
+                                    source: {
+                                        sourceId: string;
+                                        revision: string;
+                                        contentDigest: string;
+                                    };
+                                    definition: {
+                                        key: string;
+                                        contentDigest: string;
+                                        sourceLocator: string;
+                                        allowedValues: string[];
+                                    };
+                                    allowedOutcomes: string[];
+                                    rules: {
+                                        id: string;
+                                        sourceLocator: string;
+                                        contentDigest: string;
+                                        when: {
+                                            key: string;
+                                            equals: string;
+                                        };
+                                        outcome: string;
+                                    }[];
+                                };
+                            };
+                            evidencePolicy: {
+                                maxAgeMs: number;
+                                allowedSourceClasses: string[];
+                                trustDomain: string;
+                            };
+                            resolutionPolicy: "strict-single-value/v1";
+                        };
+                        semantics: {
+                            source: {
+                                candidate: {
+                                    schema: "felspar.pack-candidate.draft/v0";
+                                    candidateId: string;
+                                    authority: {
+                                        kind: "proposal";
+                                        job: string;
+                                        source: {
+                                            sourceId: string;
+                                            revision: string;
+                                            contentDigest: string;
+                                        };
+                                        definition: {
+                                            key: string;
+                                            contentDigest: string;
+                                            sourceLocator: string;
+                                            allowedValues: string[];
+                                        };
+                                        allowedOutcomes: string[];
+                                        rules: {
+                                            id: string;
+                                            sourceLocator: string;
+                                            contentDigest: string;
+                                            when: {
+                                                key: string;
+                                                equals: string;
+                                            };
+                                            outcome: string;
+                                        }[];
+                                    };
+                                };
+                                bundle: {
+                                    schema: "felspar.source-text-bundle.draft/v0";
+                                    sources: {
+                                        sourceId: string;
+                                        revision: string;
+                                        text: string;
+                                        offsetUnit: "utf16_code_units";
+                                        passages: {
+                                            locator: string;
+                                            start: number;
+                                            end: number;
+                                        }[];
+                                    }[];
+                                };
+                                compositions: {
+                                    schema: "felspar.source-compositions.draft/v0";
+                                    transformContract: "felspar.ordered-source-passage-join/v1";
+                                    candidateDigest: string;
+                                    entries: {
+                                        source: {
+                                            sourceId: string;
+                                            revision: string;
+                                        };
+                                        locator: string;
+                                        parts: string[];
+                                        separator: "" | "\n" | "\n\n";
+                                    }[];
+                                };
+                            };
+                            proposal: {
+                                values: {
+                                    value: string;
+                                    definitionLocator: string;
+                                    inclusions: string[];
+                                    exclusions: string[];
+                                    examples: string[];
+                                    edgeCases: string[];
+                                }[];
+                                normalization: {
+                                    id: string;
+                                    version: string;
+                                    instructions: string;
+                                };
+                            };
+                        };
+                        expectedSemanticBundleDigest: string;
+                        evaluatorContract: {
+                            schema: "felspar.evaluator-contract.draft/v0";
+                            authority: "unapproved";
+                            id: string;
+                            version: string;
+                            semanticDefinitionDigest: string;
+                            normalizationProposalDigest: string;
+                            evaluator: {
+                                provider: string;
+                                requestedModel: string;
+                                resolvedModel: string;
+                            };
+                            calibration: {
+                                id: string;
+                                version: string;
+                                contentDigest: string;
+                            };
+                            minimumSelectedProbability: number;
+                            probabilityContract: "closed-distribution-unique-maximum/v1" | "closed-distribution-with-abstention/v1";
+                            inputContextContract?: "job-entity-time/v1" | undefined;
+                        };
+                        expectedEvaluatorContractDigest: string;
+                        answerType?: "boolean" | undefined;
+                    };
+                })[];
+                passages: {
+                    reference: {
+                        sourceId: string;
+                        revision: string;
+                        locator: string;
+                        contentDigest: string;
+                    };
+                    text: string;
+                }[];
+                schema: "felspar.evaluation-requests.draft/v1";
+                limits: {
+                    maxQuestions: number;
+                    maxRequestBytes: number;
+                    maxResponseBytes: number;
+                    maxRounds: number;
+                    maxTotalQuestions: number;
+                    maxTotalRequestBytes: number;
+                    maxTotalResponseBytes: number;
+                };
+            };
+        };
+        approvalObjectId: string;
+        approvalDigest: string;
+        proposalDigest: string;
+        sourceDigest: string;
+        verifiedCompilation?: {
+            schema: "felspar.verified-compilation.draft/v0";
+            engineVersion: string;
+            policyDigest: string;
+            fixtureSuiteDigest: string;
+        } | undefined;
+    }>;
+    describeJob: (id: string, job: string) => Promise<{
+        schema: "felspar.hosted-job-description.draft/v0";
+        job: string;
+        trustDomain: string;
+        release: {
+            releaseId: string;
+            releaseDigest: string;
+            materialDigest: string;
+            expectedAuthorityDigest: string;
+        };
+        resolutionPolicy: "relative-date-required-types/direct-overrides/v5" | "relational-required-types/direct-overrides/v4" | "scored-required-types/mandatory-gates/v6" | "windowed-required-types/mandatory-gates/v7" | "conditional-required-types/direct-overrides/v3" | "strict-required-types/direct-overrides/v2" | "strict-required-values/direct-overrides/v1";
+        questions: {
+            definition: {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                allowedValues: string[];
+            } | {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                valueRule: {
+                    type: "boolean";
+                };
+            } | {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                valueRule: {
+                    type: "number";
+                    integer: boolean;
+                    minimum: number;
+                    maximum: number;
+                };
+                unit: string;
+            } | {
+                key: string;
+                contentDigest: string;
+                sourceLocator: string;
+                valueRule: {
+                    type: "date";
+                };
+            };
+            evidencePolicy: {
+                maxAgeMs: number;
+                allowedSourceClasses: string[];
+                trustDomain: string;
+            };
+            key: string;
+            type: "number" | "boolean" | "date" | "enum";
+            meaning: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            };
+            answer: {
+                send: "text" | "text_or_value";
+                valueFormat: "number" | "calendar-date" | null;
+                interpretation: "classified" | "exact_read" | "unsupported";
+                threshold: number | null;
+                applies: "always" | "conditional";
+                dependsOn: string[];
+                appliesWhen: string | null;
+                reading?: {
+                    version: "felspar.exact-number/v2";
+                    unit: {
+                        kind: "currency";
+                        code: string;
+                    } | {
+                        kind: "percent";
+                    } | {
+                        kind: "count";
+                        words: string[];
+                    };
+                    numberStyle: "1,234.56" | "1.234,56" | "1 234,56" | "1'234.56";
+                } | {
+                    version: "felspar.exact-date/v2";
+                    dateOrder: "unstated" | "month-first" | "day-first";
+                } | undefined;
+            };
+            requiredWhen?: ({
+                key: string;
+                relativeDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    anchorKey: string;
+                    offsetDays: number;
+                    calendar: {
+                        kind: "business_days";
+                        id: string;
+                        version: string;
+                        validFrom: string;
+                        validThrough: string;
+                        workingWeekdays: number[];
+                        holidays: string[];
+                    } | {
+                        kind: "calendar_days";
+                    };
+                };
+            } | {
+                key: string;
+                relativeToDecision: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    offsetDays: number;
+                    timeZone: string;
+                };
+            } | {
+                key: string;
+                equals: string | boolean;
+            } | {
+                key: string;
+                oneOf: string[];
+            } | {
+                key: string;
+                compare: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: number;
+                };
+            } | {
+                key: string;
+                compareFact: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    key: string;
+                };
+            } | {
+                key: string;
+                compareDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: string;
+                };
+            })[] | undefined;
+            answers?: {
+                value: string;
+                meaning: string | null;
+                inclusions: string[];
+                exclusions: string[];
+                examples: string[];
+                edgeCases: string[];
+            }[] | undefined;
+            whereToLook?: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            }[] | undefined;
+        }[];
+        rules: {
+            id: string;
+            sourceLocator: string;
+            contentDigest: string;
+            when: ({
+                key: string;
+                relativeDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    anchorKey: string;
+                    offsetDays: number;
+                    calendar: {
+                        kind: "business_days";
+                        id: string;
+                        version: string;
+                        validFrom: string;
+                        validThrough: string;
+                        workingWeekdays: number[];
+                        holidays: string[];
+                    } | {
+                        kind: "calendar_days";
+                    };
+                };
+            } | {
+                key: string;
+                relativeToDecision: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    offsetDays: number;
+                    timeZone: string;
+                };
+            } | {
+                key: string;
+                equals: string | boolean;
+            } | {
+                key: string;
+                oneOf: string[];
+            } | {
+                key: string;
+                compare: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: number;
+                };
+            } | {
+                key: string;
+                compareFact: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    key: string;
+                };
+            } | {
+                key: string;
+                compareDate: {
+                    operator: "eq" | "lt" | "lte" | "gt" | "gte";
+                    value: string;
+                };
+            })[];
+            outcome: string;
+            overrides: string[];
+            text: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            };
+            scoreRange?: {
+                minimumUnits: number;
+                maximumUnits: number;
+            } | undefined;
+            priority?: number | undefined;
+        }[];
+        outcomes: {
+            id: string;
+            meaning: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            } | null;
+            nextStep?: {
+                text: string;
+                source: {
+                    sourceId: string;
+                    revision: string;
+                    locator: string;
+                    contentDigest: string;
+                };
+                parts: {
+                    locator: string;
+                    text: string;
+                }[];
+            } | null | undefined;
+            outputs?: {
+                id: string;
+                what: {
+                    text: string;
+                    locator: string;
+                };
+                maxCharacters: number;
+                checks: {
+                    check: string;
+                    rule: string | null;
+                    must: string;
+                }[];
+                context?: {
+                    text: string;
+                    locator: string;
+                    id: string;
+                }[] | undefined;
+            }[] | undefined;
+        }[];
+        guidance: {
+            gather: string;
+        };
+        input: {
+            jsonSchema: Record<string, unknown>;
+            example: {
+                mode: "facts";
+                executionId: string;
+                expectedReleaseDigest: string;
+                jobId: string;
+                entityId: string;
+                facts: Record<string, {
+                    text: string;
+                    source: {
+                        class: string;
+                        id: string;
+                        observedAt: string;
+                        revision?: string | undefined;
+                        locator?: string | undefined;
+                        sensitivity?: string | undefined;
+                    };
+                } | {
+                    text: string;
+                    source: {
+                        class: string;
+                        id: string;
+                        observedAt: string;
+                        revision?: string | undefined;
+                        locator?: string | undefined;
+                        sensitivity?: string | undefined;
+                    };
+                }[] | {
+                    value: string | number | boolean;
+                    source: {
+                        class: string;
+                        id: string;
+                        observedAt: string;
+                        revision?: string | undefined;
+                        locator?: string | undefined;
+                        sensitivity?: string | undefined;
+                        excerpt?: string | undefined;
+                    };
+                }>;
+            } | null;
+            exampleNote: string;
+        };
+        limits: {
+            maxEvidenceItems: number;
+            maxPassages: number;
+            facts: {
+                maxExcerptCharacters: 2000;
+                maxExcerptsPerQuestion: 3;
+                maxFactsBytes: 524288;
+                maxQuestions: 64;
+            };
+        };
+        whenUnresolved?: {
+            text: string;
+            source: {
+                sourceId: string;
+                revision: string;
+                locator: string;
+                contentDigest: string;
+            };
+            parts: {
+                locator: string;
+                text: string;
+            }[];
+        } | null | undefined;
+        attempts?: {
+            max: number;
+            withProgress: number;
+            rule: string;
+        } | undefined;
+    }>;
+    verifyReceipt: (executionObjectId: string, value: unknown) => Promise<{
+        authority: "unapproved";
+        status: "reproduced" | "mismatch";
+        mismatches: string[];
+        decided?: {
+            jobId: string;
+            entityId: string;
+            releaseId: string;
+            outcome: string | null;
+        } | undefined;
+    }>;
+};
+export {};