@ixo/decision-oracle 0.0.0-stage → 0.2.1

package/dist/lib/facts/factset.d.ts

@@ -0,0 +1,608 @@
+/**
+ * FactSet v1 — the WIRE shape this oracle asserts to the eval engine (`POST /v1/decisions`
+ * `facts`, README "How a claim flows" steps 4–5). Everything the engine's `decide()` needs from us: claim answers,
+ * attachment descriptors, the frozen ctx snapshot, and the ext/ai answers with their transcripts.
+ * After the builder returns it there is no network, no clock, and no AI anywhere in the decision —
+ * the boundary between resolve and decide is the determinism/replay guarantee (evaluator-spec §1),
+ * now drawn between two services: this oracle resolves + FREEZES, the engine decides.
+ *
+ * The engine accepts `facts` as a STRICT object (unknown keys ⇒ 400), so this schema is strict at
+ * every level and the TypeScript types are inferred from it — the two cannot drift. What is NOT on
+ * the wire, deliberately: `derived` and `formProof` (the engine computes both itself from the same
+ * chain-anchored `#rub`/`#vct`; the oracle computes neither — it never binds). `unique` and
+ * `frequency` ARE on it — optional, present iff the rubric declares the rule (duplicate detection
+ * is oracle-side) — validated here to exactly what the engine's `decide()`
+ * reads and LOOSE beyond that (the producer's forensic fields ride into the engine's trace).
+ * `frozenAt` IS `ctx.now`: one clock read per build, asserted below. Only `ext`, `ai`, `unique`
+ * and `frequency` are oracle-specific (producer.ts); every other key is plumbing the builder
+ * assembles.
+ *
+ * Facts are ASSERTED, not trusted (plan §9): the engine records `factsDigest` + this oracle's DID on
+ * its ledger and receipt, so the digest below is what a decision is bound to.
+ */
+import { z } from "zod";
+/** A CID reference — never bytes (§3: attachments are references, the files stay in their store). */
+export declare const AttachmentFact: z.ZodObject<{
+    question: z.ZodString;
+    name: z.ZodString;
+    mediaType: z.ZodString;
+    cid: z.ZodNullable<z.ZodString>;
+    size: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type AttachmentFact = z.infer<typeof AttachmentFact>;
+export declare const CtxFacts: z.ZodObject<{
+    now: z.ZodISODateTime;
+    collection: z.ZodObject<{
+        startDate: z.ZodNullable<z.ZodISODateTime>;
+        endDate: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    claim: z.ZodObject<{
+        submitter: z.ZodNullable<z.ZodString>;
+        submitterAddress: z.ZodNullable<z.ZodString>;
+        submissionDate: z.ZodNullable<z.ZodISODateTime>;
+        useIntent: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CtxFacts = z.infer<typeof CtxFacts>;
+/**
+ * The oracle's policy for the ai/image lanes (the oracle config (`defineOracle`) `policies`) — recorded so every
+ * FactSet is self-explaining ("why didn't AI run?"). Gates resolve only, never decide.
+ */
+export declare const FactSettings: z.ZodObject<{
+    allowAiChecks: z.ZodBoolean;
+    allowImageChecks: z.ZodBoolean;
+}, z.core.$strict>;
+export type FactSettings = z.infer<typeof FactSettings>;
+/** What a C2PA "Content Credentials" read established about one image (lib/facts/stock/c2pa.ts). */
+export declare const Provenance: z.ZodObject<{
+    vendor: z.ZodEnum<{
+        google: "google";
+        openai: "openai";
+        other: "other";
+        unknown: "unknown";
+    }>;
+    issuer: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    modelVersion: z.ZodOptional<z.ZodString>;
+    aiGenerated: z.ZodBoolean;
+    watermarked: z.ZodBoolean;
+    signedAt: z.ZodOptional<z.ZodString>;
+    trusted: z.ZodBoolean;
+    failures: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type Provenance = z.infer<typeof Provenance>;
+/**
+ * The §A.14.1 "why did the engine decide this" record — frozen per call. Optional on the wire; the
+ * stock connectors always produce one, and the engine stores it in its trace.
+ */
+export declare const Transcript: z.ZodObject<{
+    request: z.ZodObject<{
+        url: z.ZodString;
+        body: z.ZodUnknown;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    response: z.ZodNullable<z.ZodObject<{
+        status: z.ZodInt;
+        body: z.ZodUnknown;
+    }, z.core.$strict>>;
+    attempts: z.ZodInt;
+    elapsedMs: z.ZodInt;
+    latencyMs: z.ZodOptional<z.ZodInt>;
+    genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        promptTokens: z.ZodNumber;
+        completionTokens: z.ZodNumber;
+        cachedTokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, z.core.$strict>>>;
+    provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        cid: z.ZodNullable<z.ZodString>;
+        result: z.ZodNullable<z.ZodObject<{
+            vendor: z.ZodEnum<{
+                google: "google";
+                openai: "openai";
+                other: "other";
+                unknown: "unknown";
+            }>;
+            issuer: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            modelVersion: z.ZodOptional<z.ZodString>;
+            aiGenerated: z.ZodBoolean;
+            watermarked: z.ZodBoolean;
+            signedAt: z.ZodOptional<z.ZodString>;
+            trusted: z.ZodBoolean;
+            failures: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Transcript = z.infer<typeof Transcript>;
+export declare const ExtFact: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+    value: z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber]>;
+    reason: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    transcript: z.ZodOptional<z.ZodObject<{
+        request: z.ZodObject<{
+            url: z.ZodString;
+            body: z.ZodUnknown;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        response: z.ZodNullable<z.ZodObject<{
+            status: z.ZodInt;
+            body: z.ZodUnknown;
+        }, z.core.$strict>>;
+        attempts: z.ZodInt;
+        elapsedMs: z.ZodInt;
+        latencyMs: z.ZodOptional<z.ZodInt>;
+        genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            promptTokens: z.ZodNumber;
+            completionTokens: z.ZodNumber;
+            cachedTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strict>>>;
+        provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            cid: z.ZodNullable<z.ZodString>;
+            result: z.ZodNullable<z.ZodObject<{
+                vendor: z.ZodEnum<{
+                    google: "google";
+                    openai: "openai";
+                    other: "other";
+                    unknown: "unknown";
+                }>;
+                issuer: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                modelVersion: z.ZodOptional<z.ZodString>;
+                aiGenerated: z.ZodBoolean;
+                watermarked: z.ZodBoolean;
+                signedAt: z.ZodOptional<z.ZodString>;
+                trusted: z.ZodBoolean;
+                failures: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    onError: z.ZodEnum<{
+        reject: "reject";
+        review: "review";
+    }>;
+    detail: z.ZodString;
+    transcript: z.ZodOptional<z.ZodObject<{
+        request: z.ZodObject<{
+            url: z.ZodString;
+            body: z.ZodUnknown;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        response: z.ZodNullable<z.ZodObject<{
+            status: z.ZodInt;
+            body: z.ZodUnknown;
+        }, z.core.$strict>>;
+        attempts: z.ZodInt;
+        elapsedMs: z.ZodInt;
+        latencyMs: z.ZodOptional<z.ZodInt>;
+        genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            promptTokens: z.ZodNumber;
+            completionTokens: z.ZodNumber;
+            cachedTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strict>>>;
+        provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            cid: z.ZodNullable<z.ZodString>;
+            result: z.ZodNullable<z.ZodObject<{
+                vendor: z.ZodEnum<{
+                    google: "google";
+                    openai: "openai";
+                    other: "other";
+                    unknown: "unknown";
+                }>;
+                issuer: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                modelVersion: z.ZodOptional<z.ZodString>;
+                aiGenerated: z.ZodBoolean;
+                watermarked: z.ZodBoolean;
+                signedAt: z.ZodOptional<z.ZodString>;
+                trusted: z.ZodBoolean;
+                failures: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "status">;
+export type ExtFact = z.infer<typeof ExtFact>;
+export declare const AiFact: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+    value: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+    failedRules: z.ZodArray<z.ZodString>;
+    score: z.ZodNumber;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    transcript: z.ZodOptional<z.ZodObject<{
+        request: z.ZodObject<{
+            url: z.ZodString;
+            body: z.ZodUnknown;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        response: z.ZodNullable<z.ZodObject<{
+            status: z.ZodInt;
+            body: z.ZodUnknown;
+        }, z.core.$strict>>;
+        attempts: z.ZodInt;
+        elapsedMs: z.ZodInt;
+        latencyMs: z.ZodOptional<z.ZodInt>;
+        genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            promptTokens: z.ZodNumber;
+            completionTokens: z.ZodNumber;
+            cachedTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strict>>>;
+        provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            cid: z.ZodNullable<z.ZodString>;
+            result: z.ZodNullable<z.ZodObject<{
+                vendor: z.ZodEnum<{
+                    google: "google";
+                    openai: "openai";
+                    other: "other";
+                    unknown: "unknown";
+                }>;
+                issuer: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                modelVersion: z.ZodOptional<z.ZodString>;
+                aiGenerated: z.ZodBoolean;
+                watermarked: z.ZodBoolean;
+                signedAt: z.ZodOptional<z.ZodString>;
+                trusted: z.ZodBoolean;
+                failures: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    onError: z.ZodEnum<{
+        reject: "reject";
+        review: "review";
+    }>;
+    detail: z.ZodString;
+    transcript: z.ZodOptional<z.ZodObject<{
+        request: z.ZodObject<{
+            url: z.ZodString;
+            body: z.ZodUnknown;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>;
+        response: z.ZodNullable<z.ZodObject<{
+            status: z.ZodInt;
+            body: z.ZodUnknown;
+        }, z.core.$strict>>;
+        attempts: z.ZodInt;
+        elapsedMs: z.ZodInt;
+        latencyMs: z.ZodOptional<z.ZodInt>;
+        genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            promptTokens: z.ZodNumber;
+            completionTokens: z.ZodNumber;
+            cachedTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strict>>>;
+        provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            cid: z.ZodNullable<z.ZodString>;
+            result: z.ZodNullable<z.ZodObject<{
+                vendor: z.ZodEnum<{
+                    google: "google";
+                    openai: "openai";
+                    other: "other";
+                    unknown: "unknown";
+                }>;
+                issuer: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                modelVersion: z.ZodOptional<z.ZodString>;
+                aiGenerated: z.ZodBoolean;
+                watermarked: z.ZodBoolean;
+                signedAt: z.ZodOptional<z.ZodString>;
+                trusted: z.ZodBoolean;
+                failures: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "status">;
+export type AiFact = z.infer<typeof AiFact>;
+/**
+ * The frozen duplicate-detection fact, validated to the exact shape of every field the engine's
+ * `decide()` reads (decision-engine `schemas.ts` @ 444aeae: `ruleId`, `digest`, `scoreBps`,
+ * `band`); everything else the producer freezes (winner, candidates, aiOutcome, aiPairs, …) rides
+ * through LOOSE into the engine's trace — the audit trail behind the receipt's `unique:<ruleId>`
+ * check. `band` is a closed enum: the engine branches on `band !== "pass"`, so a typo must fail
+ * here, never misroute there.
+ */
+export declare const UniqueFact: z.ZodObject<{
+    ruleId: z.ZodString;
+    digest: z.ZodString;
+    scoreBps: z.ZodNumber;
+    band: z.ZodEnum<{
+        pass: "pass";
+        reject: "reject";
+        review: "review";
+    }>;
+}, z.core.$loose>;
+export type UniqueFact = z.infer<typeof UniqueFact>;
+/**
+ * The frozen submission-rate fact — `count`/`max` compose the engine's reason text, `breach` /
+ * `unresolved` are its branches (a Blocksync outage freezes `unresolved`, which the engine fails
+ * closed); `per` and the window bounds are wording, typed when present. Loose beyond that.
+ */
+export declare const FrequencyFact: z.ZodObject<{
+    ruleId: z.ZodString;
+    count: z.ZodInt;
+    max: z.ZodInt;
+    per: z.ZodOptional<z.ZodEnum<{
+        day: "day";
+        month: "month";
+        week: "week";
+        year: "year";
+    }>>;
+    windowStartISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    windowEndISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    breach: z.ZodBoolean;
+    unresolved: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$loose>;
+export type FrequencyFact = z.infer<typeof FrequencyFact>;
+/** The wire contract — exactly what `POST /v1/decisions` receives as `facts`, nothing else. */
+export declare const FactSetV1: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    frozenAt: z.ZodISODateTime;
+    answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    attachments: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        name: z.ZodString;
+        mediaType: z.ZodString;
+        cid: z.ZodNullable<z.ZodString>;
+        size: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    ctx: z.ZodObject<{
+        now: z.ZodISODateTime;
+        collection: z.ZodObject<{
+            startDate: z.ZodNullable<z.ZodISODateTime>;
+            endDate: z.ZodNullable<z.ZodISODateTime>;
+        }, z.core.$strict>;
+        claim: z.ZodObject<{
+            submitter: z.ZodNullable<z.ZodString>;
+            submitterAddress: z.ZodNullable<z.ZodString>;
+            submissionDate: z.ZodNullable<z.ZodISODateTime>;
+            useIntent: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    ext: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"ok">;
+        value: z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber]>;
+        reason: z.ZodNullable<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        transcript: z.ZodOptional<z.ZodObject<{
+            request: z.ZodObject<{
+                url: z.ZodString;
+                body: z.ZodUnknown;
+                headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>;
+            response: z.ZodNullable<z.ZodObject<{
+                status: z.ZodInt;
+                body: z.ZodUnknown;
+            }, z.core.$strict>>;
+            attempts: z.ZodInt;
+            elapsedMs: z.ZodInt;
+            latencyMs: z.ZodOptional<z.ZodInt>;
+            genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                promptTokens: z.ZodNumber;
+                completionTokens: z.ZodNumber;
+                cachedTokens: z.ZodNumber;
+                costUsd: z.ZodNumber;
+            }, z.core.$strict>>>;
+            provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                cid: z.ZodNullable<z.ZodString>;
+                result: z.ZodNullable<z.ZodObject<{
+                    vendor: z.ZodEnum<{
+                        google: "google";
+                        openai: "openai";
+                        other: "other";
+                        unknown: "unknown";
+                    }>;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodString>;
+                    modelVersion: z.ZodOptional<z.ZodString>;
+                    aiGenerated: z.ZodBoolean;
+                    watermarked: z.ZodBoolean;
+                    signedAt: z.ZodOptional<z.ZodString>;
+                    trusted: z.ZodBoolean;
+                    failures: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        onError: z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>;
+        detail: z.ZodString;
+        transcript: z.ZodOptional<z.ZodObject<{
+            request: z.ZodObject<{
+                url: z.ZodString;
+                body: z.ZodUnknown;
+                headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>;
+            response: z.ZodNullable<z.ZodObject<{
+                status: z.ZodInt;
+                body: z.ZodUnknown;
+            }, z.core.$strict>>;
+            attempts: z.ZodInt;
+            elapsedMs: z.ZodInt;
+            latencyMs: z.ZodOptional<z.ZodInt>;
+            genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                promptTokens: z.ZodNumber;
+                completionTokens: z.ZodNumber;
+                cachedTokens: z.ZodNumber;
+                costUsd: z.ZodNumber;
+            }, z.core.$strict>>>;
+            provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                cid: z.ZodNullable<z.ZodString>;
+                result: z.ZodNullable<z.ZodObject<{
+                    vendor: z.ZodEnum<{
+                        google: "google";
+                        openai: "openai";
+                        other: "other";
+                        unknown: "unknown";
+                    }>;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodString>;
+                    modelVersion: z.ZodOptional<z.ZodString>;
+                    aiGenerated: z.ZodBoolean;
+                    watermarked: z.ZodBoolean;
+                    signedAt: z.ZodOptional<z.ZodString>;
+                    trusted: z.ZodBoolean;
+                    failures: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "status">>;
+    ai: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"ok">;
+        value: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+        failedRules: z.ZodArray<z.ZodString>;
+        score: z.ZodNumber;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        transcript: z.ZodOptional<z.ZodObject<{
+            request: z.ZodObject<{
+                url: z.ZodString;
+                body: z.ZodUnknown;
+                headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>;
+            response: z.ZodNullable<z.ZodObject<{
+                status: z.ZodInt;
+                body: z.ZodUnknown;
+            }, z.core.$strict>>;
+            attempts: z.ZodInt;
+            elapsedMs: z.ZodInt;
+            latencyMs: z.ZodOptional<z.ZodInt>;
+            genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                promptTokens: z.ZodNumber;
+                completionTokens: z.ZodNumber;
+                cachedTokens: z.ZodNumber;
+                costUsd: z.ZodNumber;
+            }, z.core.$strict>>>;
+            provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                cid: z.ZodNullable<z.ZodString>;
+                result: z.ZodNullable<z.ZodObject<{
+                    vendor: z.ZodEnum<{
+                        google: "google";
+                        openai: "openai";
+                        other: "other";
+                        unknown: "unknown";
+                    }>;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodString>;
+                    modelVersion: z.ZodOptional<z.ZodString>;
+                    aiGenerated: z.ZodBoolean;
+                    watermarked: z.ZodBoolean;
+                    signedAt: z.ZodOptional<z.ZodString>;
+                    trusted: z.ZodBoolean;
+                    failures: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"error">;
+        onError: z.ZodEnum<{
+            reject: "reject";
+            review: "review";
+        }>;
+        detail: z.ZodString;
+        transcript: z.ZodOptional<z.ZodObject<{
+            request: z.ZodObject<{
+                url: z.ZodString;
+                body: z.ZodUnknown;
+                headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strict>;
+            response: z.ZodNullable<z.ZodObject<{
+                status: z.ZodInt;
+                body: z.ZodUnknown;
+            }, z.core.$strict>>;
+            attempts: z.ZodInt;
+            elapsedMs: z.ZodInt;
+            latencyMs: z.ZodOptional<z.ZodInt>;
+            genId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            usage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                promptTokens: z.ZodNumber;
+                completionTokens: z.ZodNumber;
+                cachedTokens: z.ZodNumber;
+                costUsd: z.ZodNumber;
+            }, z.core.$strict>>>;
+            provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                cid: z.ZodNullable<z.ZodString>;
+                result: z.ZodNullable<z.ZodObject<{
+                    vendor: z.ZodEnum<{
+                        google: "google";
+                        openai: "openai";
+                        other: "other";
+                        unknown: "unknown";
+                    }>;
+                    issuer: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodString>;
+                    modelVersion: z.ZodOptional<z.ZodString>;
+                    aiGenerated: z.ZodBoolean;
+                    watermarked: z.ZodBoolean;
+                    signedAt: z.ZodOptional<z.ZodString>;
+                    trusted: z.ZodBoolean;
+                    failures: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "status">>;
+    unique: z.ZodOptional<z.ZodObject<{
+        ruleId: z.ZodString;
+        digest: z.ZodString;
+        scoreBps: z.ZodNumber;
+        band: z.ZodEnum<{
+            pass: "pass";
+            reject: "reject";
+            review: "review";
+        }>;
+    }, z.core.$loose>>;
+    frequency: z.ZodOptional<z.ZodObject<{
+        ruleId: z.ZodString;
+        count: z.ZodInt;
+        max: z.ZodInt;
+        per: z.ZodOptional<z.ZodEnum<{
+            day: "day";
+            month: "month";
+            week: "week";
+            year: "year";
+        }>>;
+        windowStartISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        windowEndISO: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+        breach: z.ZodBoolean;
+        unresolved: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$loose>>;
+    settings: z.ZodObject<{
+        allowAiChecks: z.ZodBoolean;
+        allowImageChecks: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type FactSetV1 = z.infer<typeof FactSetV1>;
+/**
+ * `sha256(canonicalJson(facts))` — what the engine records as `factsDigest` and what a decision is
+ * bound to. Canonical JSON (sorted keys, no whitespace) makes it independent of key order, so a
+ * FactSet that round-trips through JSON digests identically on both sides.
+ */
+export declare function factsDigest(facts: FactSetV1): Promise<string>;
+//# sourceMappingURL=factset.d.ts.map

package/dist/lib/facts/factset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factset.d.ts","sourceRoot":"","sources":["../../../src/lib/facts/factset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,qGAAqG;AACrG,eAAO,MAAM,cAAc;;;;;;kBAOzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAW5D,eAAO,MAAM,QAAQ;;;;;;;;;;;;kBAkBnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,YAAY;;;kBAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,oGAAoG;AACpG,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;kBAcrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4CrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAMpD,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAclB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAE9C,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAmBjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE5C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;;;;;iBAKrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;iBASxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,+FAA+F;AAC/F,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBnB,CAAC;AACJ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAE7D"}