@hcs-witness/verify 0.0.0 → 1.0.0

package/dist/ots.js

@@ -0,0 +1,386 @@
+import { sha256 } from "./hash.js";
+/**
+ * Client OpenTimestamps minimal (ADR 0009) — format .ots uniquement.
+ * Périmètre strict : opérations sha256 / append / prepend,
+ * attestations pending et Bitcoin. Toute autre opération ou
+ * attestation est une erreur explicite, jamais ignorée. Aucun réseau.
+ *
+ * Référence du format : opentimestamps/python-opentimestamps,
+ * opentimestamps/core/{timestamp,op,notary,serialize}.py.
+ */
+export class OtsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "OtsError";
+        this.code = code;
+    }
+}
+const MAGIC = Uint8Array.from([
+    ...new TextEncoder().encode("\0OpenTimestamps\0\0Proof\0"),
+    0xbf,
+    0x89,
+    0xe2,
+    0xe8,
+    0x84,
+    0xe8,
+    0x92,
+    0x94,
+]);
+const MAJOR_VERSION = 1;
+const OP_SHA256 = 0x08;
+const OP_APPEND = 0xf0;
+const OP_PREPEND = 0xf1;
+const SEP_FORK = 0xff;
+const SEP_ATTESTATION = 0x00;
+const TAG_PENDING = "83dfe30d2ef90c8e";
+const TAG_BITCOIN = "0588960d73d71901";
+const MAX_FILE_BYTES = 64 * 1024;
+const MAX_MSG_BYTES = 4096;
+const MAX_ATTESTATION_PAYLOAD = 8192;
+const MAX_URI_BYTES = 1000;
+const MAX_DEPTH = 256;
+const MAX_NODES = 8192;
+const MAX_HEIGHT = 0xffffffff;
+const URI_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._/:";
+class Reader {
+    buf;
+    pos = 0;
+    nodes = 0;
+    constructor(buf) {
+        this.buf = buf;
+    }
+    byte() {
+        const b = this.buf.at(this.pos);
+        if (b === undefined) {
+            throw new OtsError("TRUNCATED", "unexpected end of stream");
+        }
+        this.pos += 1;
+        return b;
+    }
+    bytes(n) {
+        if (n < 0 || this.pos + n > this.buf.length) {
+            throw new OtsError("TRUNCATED", "unexpected end of stream");
+        }
+        const out = this.buf.subarray(this.pos, this.pos + n);
+        this.pos += n;
+        return out;
+    }
+    varuint() {
+        let value = 0;
+        let shift = 0;
+        for (let i = 0; i < 9; i += 1) {
+            const b = this.byte();
+            value += (b & 0x7f) * 2 ** shift;
+            if ((b & 0x80) === 0) {
+                // Canonique : le dernier octet ne peut pas valoir 0 sauf si
+                // c'est le seul octet.
+                if (b === 0 && i > 0) {
+                    throw new OtsError("VARUINT", "non-canonical varuint");
+                }
+                if (value > Number.MAX_SAFE_INTEGER) {
+                    throw new OtsError("VARUINT", "varuint overflow");
+                }
+                return value;
+            }
+            shift += 7;
+        }
+        throw new OtsError("VARUINT", "varuint too long");
+    }
+    varbytes(maxLen, minLen = 0) {
+        const n = this.varuint();
+        if (n < minLen || n > maxLen) {
+            throw new OtsError("LENGTH", `varbytes length ${String(n)} out of bounds`);
+        }
+        return this.bytes(n);
+    }
+    done() {
+        return this.pos === this.buf.length;
+    }
+}
+function applyOp(op, msg) {
+    let out;
+    if (op.kind === "sha256") {
+        out = sha256(msg);
+    }
+    else {
+        const arg = op.arg;
+        /* c8 ignore next 3 — défensif : le parseur garantit arg pour les ops binaires */
+        if (arg === undefined) {
+            throw new OtsError("OP", "binary op without arg");
+        }
+        out =
+            op.kind === "append"
+                ? Uint8Array.from([...msg, ...arg])
+                : Uint8Array.from([...arg, ...msg]);
+    }
+    /* c8 ignore next 3 — défensif : out.length === 0 impossible (ops >= 1 octet) */
+    if (out.length === 0 || out.length > MAX_MSG_BYTES) {
+        throw new OtsError("MSG_LENGTH", "message length out of bounds");
+    }
+    return out;
+}
+function hexOf(bytes) {
+    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function readAttestation(r) {
+    const tag = hexOf(r.bytes(8));
+    const payload = r.varbytes(MAX_ATTESTATION_PAYLOAD);
+    if (tag === TAG_BITCOIN) {
+        const pr = new Reader(payload);
+        const height = pr.varuint();
+        if (!pr.done()) {
+            throw new OtsError("ATTESTATION", "trailing bytes in attestation");
+        }
+        if (height > MAX_HEIGHT) {
+            throw new OtsError("ATTESTATION", "block height out of range");
+        }
+        return { kind: "bitcoin", height };
+    }
+    if (tag === TAG_PENDING) {
+        const pr = new Reader(payload);
+        const raw = pr.varbytes(MAX_URI_BYTES);
+        if (!pr.done()) {
+            throw new OtsError("ATTESTATION", "trailing bytes in attestation");
+        }
+        let uri;
+        try {
+            uri = new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        }
+        catch {
+            throw new OtsError("ATTESTATION", "pending URI is not valid UTF-8");
+        }
+        for (const ch of uri) {
+            if (!URI_ALLOWED.includes(ch)) {
+                throw new OtsError("ATTESTATION", "forbidden char in pending URI");
+            }
+        }
+        return { kind: "pending", uri };
+    }
+    throw new OtsError("UNKNOWN_ATTESTATION", `unknown attestation tag ${tag}`);
+}
+function readTimestamp(r, initialMsg, depth) {
+    if (depth > MAX_DEPTH) {
+        throw new OtsError("DEPTH", "timestamp tree too deep");
+    }
+    /* c8 ignore next 3 — défensif : l'en-tête impose un digest de 32 octets */
+    if (initialMsg.length === 0 || initialMsg.length > MAX_MSG_BYTES) {
+        throw new OtsError("MSG_LENGTH", "message length out of bounds");
+    }
+    r.nodes += 1;
+    /* c8 ignore next 3 — défensif : > 8192 nœuds excéderait la borne fichier de 64 Ko */
+    if (r.nodes > MAX_NODES) {
+        throw new OtsError("NODES", "timestamp tree too large");
+    }
+    const stamp = { msg: initialMsg, attestations: [], ops: [] };
+    const seenOps = new Set();
+    const readItem = (tag) => {
+        if (tag === SEP_ATTESTATION) {
+            stamp.attestations.push(readAttestation(r));
+            return;
+        }
+        let op;
+        if (tag === OP_SHA256) {
+            op = { kind: "sha256" };
+        }
+        else if (tag === OP_APPEND || tag === OP_PREPEND) {
+            op = {
+                kind: tag === OP_APPEND ? "append" : "prepend",
+                arg: r.varbytes(MAX_MSG_BYTES, 1),
+            };
+        }
+        else {
+            throw new OtsError("UNKNOWN_OP", `unsupported operation tag 0x${tag.toString(16)}`);
+        }
+        const key = `${String(tag)}:${hexOf(op.arg ?? new Uint8Array())}`;
+        if (seenOps.has(key)) {
+            throw new OtsError("DUPLICATE_OP", "repeated operation in timestamp");
+        }
+        seenOps.add(key);
+        stamp.ops.push({
+            op,
+            stamp: readTimestamp(r, applyOp(op, initialMsg), depth + 1),
+        });
+    };
+    let tag = r.byte();
+    while (tag === SEP_FORK) {
+        readItem(r.byte());
+        tag = r.byte();
+    }
+    readItem(tag);
+    return stamp;
+}
+/** Lit un fichier .ots complet. Jamais d'exception non gérée : OtsError. */
+export function parseOtsFile(input) {
+    if (!(input instanceof Uint8Array)) {
+        throw new OtsError("TYPE", "input must be a Uint8Array");
+    }
+    if (input.length === 0 || input.length > MAX_FILE_BYTES) {
+        throw new OtsError("SIZE", "file size out of bounds");
+    }
+    const r = new Reader(input);
+    const magic = r.bytes(MAGIC.length);
+    if (hexOf(magic) !== hexOf(MAGIC)) {
+        throw new OtsError("BAD_MAGIC", "bad file magic");
+    }
+    if (r.varuint() !== MAJOR_VERSION) {
+        throw new OtsError("VERSION", "unsupported .ots major version");
+    }
+    const fileHashOp = r.byte();
+    if (fileHashOp !== OP_SHA256) {
+        throw new OtsError("FILE_HASH_OP", `unsupported file digest op 0x${fileHashOp.toString(16)}`);
+    }
+    const fileDigest = r.bytes(32);
+    const timestamp = readTimestamp(r, fileDigest, 0);
+    if (!r.done()) {
+        throw new OtsError("TRAILING", "trailing garbage after timestamp");
+    }
+    return { fileDigest, timestamp };
+}
+/* ------------------------------------------------------------------ */
+/* Sérialisation canonique (miroir de timestamp.py serialize)          */
+/* ------------------------------------------------------------------ */
+class Writer {
+    out = [];
+    byte(b) {
+        this.out.push(b);
+    }
+    bytes(bs) {
+        for (const b of bs)
+            this.out.push(b);
+    }
+    varuint(value) {
+        let v = value;
+        for (;;) {
+            const b = v % 128;
+            v = Math.floor(v / 128);
+            if (v === 0) {
+                this.byte(b);
+                return;
+            }
+            this.byte(b | 0x80);
+        }
+    }
+    varbytes(bs) {
+        this.varuint(bs.length);
+        this.bytes(bs);
+    }
+    toBytes() {
+        return Uint8Array.from(this.out);
+    }
+}
+function bytesFromHex(hex) {
+    /* c8 ignore next — défensif : les tags internes sont de longueur paire */
+    return Uint8Array.from(hex.match(/../g) ?? [], (pair) => Number.parseInt(pair, 16));
+}
+function opSortKey(op) {
+    const tag = op.kind === "sha256"
+        ? OP_SHA256
+        : op.kind === "append"
+            ? OP_APPEND
+            : OP_PREPEND;
+    return Uint8Array.from([tag, ...(op.arg ?? [])]);
+}
+function cmpBytes(a, b) {
+    for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
+        /* c8 ignore next — défensif : i < min(len) garantit la présence */
+        const d = (a.at(i) ?? 0) - (b.at(i) ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return a.length - b.length;
+}
+function attTag(att) {
+    return bytesFromHex(att.kind === "bitcoin" ? TAG_BITCOIN : TAG_PENDING);
+}
+function writeAttestation(w, att) {
+    w.bytes(attTag(att));
+    const p = new Writer();
+    if (att.kind === "bitcoin") {
+        p.varuint(att.height ?? 0);
+    }
+    else {
+        p.varbytes(new TextEncoder().encode(att.uri ?? ""));
+    }
+    w.varbytes(p.toBytes());
+}
+function writeOp(w, op) {
+    w.byte(op.kind === "sha256"
+        ? OP_SHA256
+        : op.kind === "append"
+            ? OP_APPEND
+            : OP_PREPEND);
+    if (op.arg !== undefined) {
+        w.varbytes(op.arg);
+    }
+}
+/** Sérialise un Timestamp (ordre canonique : attestations puis ops). */
+export function serializeTimestamp(stamp) {
+    const w = new Writer();
+    const atts = [...stamp.attestations].sort((a, b) => cmpBytes(attTag(a), attTag(b)));
+    const ops = [...stamp.ops].sort((x, y) => cmpBytes(opSortKey(x.op), opSortKey(y.op)));
+    for (const att of atts.slice(0, -1)) {
+        w.byte(SEP_FORK);
+        w.byte(SEP_ATTESTATION);
+        writeAttestation(w, att);
+    }
+    const lastAtt = atts.at(-1);
+    if (ops.length === 0) {
+        if (lastAtt === undefined) {
+            throw new OtsError("EMPTY", "empty timestamp cannot be serialized");
+        }
+        w.byte(SEP_ATTESTATION);
+        writeAttestation(w, lastAtt);
+    }
+    else {
+        if (lastAtt !== undefined) {
+            w.byte(SEP_FORK);
+            w.byte(SEP_ATTESTATION);
+            writeAttestation(w, lastAtt);
+        }
+        for (const { op, stamp: sub } of ops.slice(0, -1)) {
+            w.byte(SEP_FORK);
+            writeOp(w, op);
+            w.bytes(serializeTimestamp(sub));
+        }
+        const last = ops.at(-1);
+        /* c8 ignore next 3 — défensif : ops.length > 0 garanti en amont */
+        if (last === undefined) {
+            throw new OtsError("EMPTY", "no operations");
+        }
+        writeOp(w, last.op);
+        w.bytes(serializeTimestamp(last.stamp));
+    }
+    return w.toBytes();
+}
+/** Fabrique un fichier .ots : magic ‖ version ‖ sha256 ‖ digest ‖ timestamp. */
+export function serializeOtsFile(fileDigest, timestampBytes) {
+    if (fileDigest.length !== 32) {
+        throw new OtsError("DIGEST", "file digest must be 32 bytes");
+    }
+    return Uint8Array.from([
+        ...MAGIC,
+        MAJOR_VERSION,
+        OP_SHA256,
+        ...fileDigest,
+        ...timestampBytes,
+    ]);
+}
+/** Toutes les attestations de l'arbre (avec le msg attesté). */
+export function allAttestations(stamp) {
+    const out = stamp.attestations.map((attestation) => ({
+        msg: stamp.msg,
+        attestation,
+    }));
+    for (const { stamp: sub } of stamp.ops) {
+        out.push(...allAttestations(sub));
+    }
+    return out;
+}
+/** Plus petite hauteur de bloc Bitcoin attestée, si présente. */
+export function bitcoinBlockHeight(stamp) {
+    const heights = allAttestations(stamp)
+        .filter((a) => a.attestation.kind === "bitcoin")
+        .map((a) => a.attestation.height ?? 0);
+    return heights.length === 0 ? undefined : Math.min(...heights);
+}

package/dist/schema.d.ts

@@ -0,0 +1,74 @@
+import { type JsonSchema } from "./check.js";
+/** Schéma JSON du document signé — contrat de format, immuable sans ADR. */
+export declare const proofSchema: JsonSchema;
+/** Partie signée de la preuve (payload JCS sans `sig` ni `anchor`). */
+export declare const unsignedProofSchema: JsonSchema;
+export interface PresenceChallenge {
+    kind: "color" | "numeric" | "stroop" | "size";
+    /** Niveau de décision : absent sur les preuves antérieures à prof-3. */
+    level?: "standard" | "enhanced";
+    trials: number;
+    completed: boolean;
+}
+/** Bloc présence : consigné dans la preuve signée, JAMAIS utilisé pour la
+ *  validité cryptographique. Présent sur v:2, absent sur v:1. */
+export interface Presence {
+    model: "presence-v1";
+    calibrated: false;
+    band: "unrated";
+    challenge: PresenceChallenge;
+    signals: "trusted" | "untrusted" | "absent";
+    automation_indicators: number;
+    profile_sha256: string | null;
+    rotation: {
+        tw: number;
+        ok: boolean;
+        replayed: boolean;
+    };
+    flags: string[];
+}
+export interface ProofSignature {
+    kid: string;
+    value: string;
+}
+export interface ProofAnchor {
+    batch_id: string;
+    merkle_root: string;
+    leaf_index: number;
+    path: string[];
+    ots?: string;
+    bitcoin_block_height?: number;
+}
+export interface UnsignedProof {
+    v: 1 | 2;
+    proof_id: string;
+    tenant_id: string;
+    approval_id: string;
+    action: string;
+    subject_ref: string;
+    context_sha256: string;
+    display_sha256: string;
+    decision: "approved" | "denied" | "expired";
+    human_factor: {
+        method: "webauthn";
+        user_verified: true;
+        credential_id_sha256: string;
+        authenticator_aaguid: string;
+    };
+    signals?: Record<string, unknown>;
+    presence?: Presence;
+    issued_at: string;
+    expires_at: string;
+}
+export interface Proof extends UnsignedProof {
+    sig: {
+        es256: ProofSignature;
+        mldsa65: ProofSignature;
+    };
+    anchor?: ProofAnchor;
+}
+export declare function isProof(value: unknown): value is Proof;
+export declare function isUnsignedProof(value: unknown): value is UnsignedProof;
+/** Canonical JCS bytes of the proof without `sig` and `anchor` (SPEC §3). */
+export declare function signedPayload(proof: UnsignedProof): Uint8Array;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAgK1D,4EAA4E;AAC5E,eAAO,MAAM,WAAW,EAAE,UA6BzB,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,mBAAmB,EAAE,UAKjC,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC9C,wEAAwE;IACxE,KAAK,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;iEACiE;AACjE,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,EAAE,KAAK,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,OAAO,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC5C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,EAAE;QACR,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,OAAO,CAAC;QACZ,QAAQ,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC5C,YAAY,EAAE;QACZ,MAAM,EAAE,UAAU,CAAC;QACnB,aAAa,EAAE,IAAI,CAAC;QACpB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,oBAAoB,EAAE,MAAM,CAAC;KAC9B,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,KAAM,SAAQ,aAAa;IAC1C,GAAG,EAAE;QACH,KAAK,EAAE,cAAc,CAAC;QACtB,OAAO,EAAE,cAAc,CAAC;KACzB,CAAC;IACF,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEtD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEtE;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAK9D"}

package/dist/schema.js

@@ -0,0 +1,201 @@
+import { checkSchema } from "./check.js";
+import { canonicalBytes } from "./jcs.js";
+const ULID_CHARS = "[0-9A-HJKMNP-TV-Z]{26}";
+const ulidString = (prefix) => ({
+    type: "string",
+    pattern: `^${prefix}_${ULID_CHARS}$`,
+});
+const hex64 = { type: "string", pattern: "^[0-9a-f]{64}$" };
+const b64url = { type: "string", pattern: "^[A-Za-z0-9_-]+$" };
+const rfc3339Utc = {
+    type: "string",
+    pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?Z$",
+};
+const uuid = {
+    type: "string",
+    pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+};
+const presenceChallengeSchema = {
+    type: "object",
+    required: ["kind", "trials", "completed"],
+    additionalProperties: false,
+    properties: {
+        kind: {
+            anyOf: [
+                { const: "color", type: "string" },
+                { const: "numeric", type: "string" },
+                { const: "stroop", type: "string" },
+                { const: "size", type: "string" },
+            ],
+        },
+        level: {
+            anyOf: [
+                { const: "standard", type: "string" },
+                { const: "enhanced", type: "string" },
+            ],
+        },
+        trials: { type: "integer", minimum: 0 },
+        completed: { type: "boolean" },
+    },
+};
+const presenceSchema = {
+    type: "object",
+    required: [
+        "model",
+        "calibrated",
+        "band",
+        "challenge",
+        "signals",
+        "automation_indicators",
+        "profile_sha256",
+        "rotation",
+        "flags",
+    ],
+    additionalProperties: false,
+    properties: {
+        model: { const: "presence-v1", type: "string" },
+        calibrated: { const: false, type: "boolean" },
+        band: { const: "unrated", type: "string" },
+        challenge: presenceChallengeSchema,
+        signals: {
+            anyOf: [
+                { const: "trusted", type: "string" },
+                { const: "untrusted", type: "string" },
+                { const: "absent", type: "string" },
+            ],
+        },
+        automation_indicators: { type: "integer", minimum: 0 },
+        profile_sha256: { anyOf: [hex64, { type: "null" }] },
+        rotation: {
+            type: "object",
+            required: ["tw", "ok", "replayed"],
+            additionalProperties: false,
+            properties: {
+                tw: { type: "integer", minimum: 0 },
+                ok: { type: "boolean" },
+                replayed: { type: "boolean" },
+            },
+        },
+        flags: { type: "array", items: { type: "string" } },
+    },
+};
+const signatureSchema = {
+    type: "object",
+    required: ["kid", "value"],
+    additionalProperties: false,
+    properties: {
+        kid: { type: "string", minLength: 1 },
+        value: b64url,
+    },
+};
+const humanFactorSchema = {
+    type: "object",
+    required: [
+        "method",
+        "user_verified",
+        "credential_id_sha256",
+        "authenticator_aaguid",
+    ],
+    additionalProperties: false,
+    properties: {
+        method: { const: "webauthn", type: "string" },
+        user_verified: { const: true, type: "boolean" },
+        credential_id_sha256: hex64,
+        authenticator_aaguid: uuid,
+    },
+};
+const unsignedProofProperties = {
+    v: {
+        anyOf: [
+            { const: 1, type: "number" },
+            { const: 2, type: "number" },
+        ],
+    },
+    proof_id: ulidString("ggp"),
+    tenant_id: ulidString("tnt"),
+    approval_id: ulidString("apr"),
+    action: { type: "string", pattern: "^[a-z0-9]+(\\.[a-z0-9_]+){1,5}$" },
+    subject_ref: { type: "string", minLength: 1 },
+    context_sha256: hex64,
+    display_sha256: hex64,
+    decision: {
+        anyOf: [
+            { const: "approved", type: "string" },
+            { const: "denied", type: "string" },
+            { const: "expired", type: "string" },
+        ],
+    },
+    human_factor: humanFactorSchema,
+    signals: {
+        type: "object",
+        patternProperties: { "^(.*)$": {} },
+    },
+    presence: presenceSchema,
+    issued_at: rfc3339Utc,
+    expires_at: rfc3339Utc,
+};
+const unsignedProofRequired = [
+    "v",
+    "proof_id",
+    "tenant_id",
+    "approval_id",
+    "action",
+    "subject_ref",
+    "context_sha256",
+    "display_sha256",
+    "decision",
+    "human_factor",
+    "issued_at",
+    "expires_at",
+];
+/** Schéma JSON du document signé — contrat de format, immuable sans ADR. */
+export const proofSchema = {
+    type: "object",
+    required: [...unsignedProofRequired, "sig"],
+    additionalProperties: false,
+    properties: {
+        ...unsignedProofProperties,
+        sig: {
+            type: "object",
+            required: ["es256", "mldsa65"],
+            additionalProperties: false,
+            properties: {
+                es256: signatureSchema,
+                mldsa65: signatureSchema,
+            },
+        },
+        anchor: {
+            type: "object",
+            required: ["batch_id", "merkle_root", "leaf_index", "path"],
+            additionalProperties: false,
+            properties: {
+                batch_id: { type: "string", minLength: 1 },
+                merkle_root: hex64,
+                leaf_index: { type: "integer", minimum: 0 },
+                path: { type: "array", items: hex64 },
+                ots: { type: "string", minLength: 1 },
+                bitcoin_block_height: { type: "integer", minimum: 0 },
+            },
+        },
+    },
+};
+/** Partie signée de la preuve (payload JCS sans `sig` ni `anchor`). */
+export const unsignedProofSchema = {
+    type: "object",
+    required: unsignedProofRequired,
+    additionalProperties: false,
+    properties: unsignedProofProperties,
+};
+export function isProof(value) {
+    return checkSchema(proofSchema, value);
+}
+export function isUnsignedProof(value) {
+    return checkSchema(unsignedProofSchema, value);
+}
+/** Canonical JCS bytes of the proof without `sig` and `anchor` (SPEC §3). */
+export function signedPayload(proof) {
+    const unsigned = { ...proof };
+    delete unsigned.sig;
+    delete unsigned.anchor;
+    return canonicalBytes(unsigned);
+}

package/dist/verify.d.ts

@@ -0,0 +1,12 @@
+export declare const ML_DSA_CONTEXT: Uint8Array<ArrayBuffer>;
+export type VerifyErrorCode = "SCHEMA_INVALID" | "UNSUPPORTED_VERSION" | "KEYSET_INVALID" | "ES256_KID_UNKNOWN" | "MLDSA_KID_UNKNOWN" | "ES256_SIG_INVALID" | "MLDSA_SIG_INVALID" | "ES256_HIGH_S" | "KEY_NOT_VALID_AT_ISSUANCE" | "PROOF_EXPIRED" | "TIMESTAMPS_INCOHERENT";
+export interface VerifyResult {
+    readonly valid: boolean;
+    readonly errors: readonly VerifyErrorCode[];
+    readonly proof_id?: string;
+}
+export interface VerifyOptions {
+    readonly now?: Date;
+}
+export declare function verifyProof(proof: unknown, keyset: unknown, opts?: VerifyOptions): VerifyResult;
+//# sourceMappingURL=verify.d.ts.map

package/dist/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../src/verify.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,cAAc,yBAAiD,CAAC;AAQ7E,MAAM,MAAM,eAAe,GACvB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,GAChB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,cAAc,GACd,2BAA2B,GAC3B,eAAe,GACf,uBAAuB,CAAC;AAE5B,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;CACrB;AAcD,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,EACf,IAAI,CAAC,EAAE,aAAa,GACnB,YAAY,CAuId"}