@zanii/certify 0.0.0-stage → 0.6.0

package/dist/register.d.ts

@@ -0,0 +1,79 @@
+import type { Credential } from "@zanii/credentials";
+import { type BoardCheck, type BodySignature } from "./board.ts";
+import { type LicenceScope } from "./licence.ts";
+import type { Signer } from "./signer.ts";
+import type { SchemeLogsInput } from "./scheme-log.ts";
+export interface RegisteredBody {
+    did: string;
+    name: string;
+    /** The accreditation body (EIAC, GAC, IAF member). */
+    accreditation_body: string;
+    certificate_number: string;
+    /** The profiles and levels the accreditation covers. */
+    scope: LicenceScope[];
+    valid_until: string;
+}
+export interface BodyRegisterInput {
+    seq: number;
+    prev: string | null;
+    bodies: readonly {
+        did: string;
+        name: string;
+        accreditation_body: string;
+        certificate_number: string;
+        scope: readonly {
+            profile: string;
+            levels: readonly number[];
+        }[];
+        valid_until: string;
+    }[];
+    effectiveFrom: string;
+    /** jcsHash of the board that signs (the newest board when it is appended). */
+    board: string;
+}
+export type BodyRegisterBody = {
+    v: 1;
+    type: "certify.body-register";
+    seq: number;
+    prev: string | null;
+    bodies: RegisteredBody[];
+    effective_from: string;
+    board: string;
+};
+export type BodyRegister = BodyRegisterBody & {
+    signatures: BodySignature[];
+};
+declare function registerError(r: Record<string, unknown>): string | null;
+export { registerError as registerFieldError };
+/** Section 1: the unsigned register; bodies sorted by DID, scopes normalised. */
+export declare function bodyRegisterBody(f: BodyRegisterInput): BodyRegisterBody;
+/** A register signed by `signers` (k members of the board it names). */
+export declare function buildBodyRegister(f: BodyRegisterInput, signers: readonly Signer[]): Promise<BodyRegister>;
+export declare const isBodyRegister: (r: unknown) => r is Record<string, unknown>;
+/** Section 2: the register log: the board log verifies; each register at seq i naming i - 1, effective_from rising, signed by k of the board in force. */
+export declare function verifyBodyRegisterLog(registers: readonly unknown[], boards: readonly unknown[], opts?: {
+    owner?: string;
+    schemeLog?: SchemeLogsInput;
+}): BoardCheck;
+/** Section 3: the register in force at `at` (the newest with effective_from at or before it), or null. */
+export declare function bodyRegisterAt(registers: readonly unknown[], at: string): BodyRegister | null;
+/** Section 3: the DIDs the register in force at `at` lists, accredited at `at` (and, given, for that profile and level). */
+export declare function trustedBodiesAt(registers: readonly unknown[], at: string, scope?: {
+    profile?: string;
+    level?: number;
+}): string[];
+/** `verifyCertificate`'s `bodyRegister` option: the scheme log's board and register entries. */
+export interface BodyRegisterOptions {
+    owner: string;
+    boards: readonly unknown[];
+    registers: readonly unknown[];
+    schemeLog?: SchemeLogsInput;
+}
+/**
+ * Section 3: the trusted bodies for a Level 3 certificate's audit from the register in force when
+ * it was issued, and the reasons the audit's body is not one of them.
+ */
+export declare function registerTrust(cert: Credential, auditBody: unknown, opts: BodyRegisterOptions): {
+    trusted: string[];
+    reasons: string[];
+};

package/dist/register.js

@@ -0,0 +1,134 @@
+// spec/body-register.md: the board-signed register of trusted certification bodies (ISO/IEC 17065
+// or 17021 accredited), published in the scheme log, which verifiers read instead of a local list.
+import { jcsHash } from "@zanii/core";
+import { bodySignature, boardSignedReasons, verifyBoardLog, withSignatures } from "./board.js";
+import { normaliseScope, scopeError } from "./licence.js";
+import { isDid, isIso, isObj, isSha, ms } from "./shared.js";
+import { logPositionOk } from "./status.js";
+import { schemeAuthority } from "./scheme-authority.js";
+const text = (v, max) => typeof v === "string" && v.length >= 1 && v.length <= max;
+function bodyError(b) {
+    if (!isObj(b) || Object.keys(b).length !== 6 || !isDid(b.did))
+        return "each body is {did, name, accreditation_body, certificate_number, scope, valid_until}";
+    if (!text(b.name, 200) || !text(b.accreditation_body, 200))
+        return "name and accreditation_body must be 1 to 200 characters";
+    if (!text(b.certificate_number, 100))
+        return "certificate_number must be 1 to 100 characters";
+    const se = scopeError(b.scope);
+    if (se)
+        return se;
+    if (!isIso(b.valid_until))
+        return "valid_until must be an ISO timestamp";
+    return null;
+}
+function registerError(r) {
+    if (!logPositionOk(r.seq, r.prev))
+        return "seq and prev are not a log position";
+    const bs = r.bodies;
+    if (!Array.isArray(bs) || bs.length < 1 || bs.length > 1000)
+        return "bodies must list 1 to 1000 bodies";
+    for (const b of bs) {
+        const err = bodyError(b);
+        if (err)
+            return err;
+    }
+    if (bs.some((b, i) => i > 0 && !(b.did > bs[i - 1].did)))
+        return "bodies must be sorted by did, each body once";
+    if (!isIso(r.effective_from))
+        return "effective_from must be an ISO timestamp";
+    if (!isSha(r.board))
+        return "board must be a board hash";
+    return null;
+}
+export { registerError as registerFieldError };
+/** Section 1: the unsigned register; bodies sorted by DID, scopes normalised. */
+export function bodyRegisterBody(f) {
+    const bodies = Array.isArray(f.bodies)
+        ? f.bodies
+            .map((b) => ({ did: b?.did, name: b?.name, accreditation_body: b?.accreditation_body, certificate_number: b?.certificate_number, scope: normaliseScope(b?.scope), valid_until: b?.valid_until }))
+            .sort((a, b) => (a.did < b.did ? -1 : a.did > b.did ? 1 : 0))
+        : f.bodies;
+    const body = { v: 1, type: "certify.body-register", seq: f.seq, prev: f.prev, bodies, effective_from: f.effectiveFrom, board: f.board };
+    const err = registerError(body);
+    if (err)
+        throw new Error(err);
+    return body;
+}
+/** A register signed by `signers` (k members of the board it names). */
+export async function buildBodyRegister(f, signers) {
+    const body = bodyRegisterBody(f);
+    return withSignatures(body, await Promise.all(signers.map((s) => bodySignature(body, s))));
+}
+export const isBodyRegister = (r) => isObj(r) && r.v === 1 && r.type === "certify.body-register" && Object.keys(r).length === 8;
+/** Section 2: the register log: the board log verifies; each register at seq i naming i - 1, effective_from rising, signed by k of the board in force. */
+export function verifyBodyRegisterLog(registers, boards, opts = {}) {
+    if (opts.schemeLog !== undefined) {
+        const { reasons } = schemeAuthority(opts.schemeLog, opts.owner, { "certify.board": boards, "certify.body-register": registers });
+        return { ok: reasons.length === 0, reasons };
+    }
+    const reasons = [...verifyBoardLog(boards, opts).reasons];
+    if (!Array.isArray(registers) || registers.length === 0)
+        return { ok: false, reasons: [...reasons, "the body register log is empty"] };
+    const bl = Array.isArray(boards) ? boards : [];
+    registers.forEach((r, i) => {
+        if (!isBodyRegister(r)) {
+            reasons.push(`register ${i} is not a body register (v1)`);
+            return;
+        }
+        const err = registerError(r);
+        if (err) {
+            reasons.push(`register ${i} is malformed: ${err}`);
+            return;
+        }
+        const prev = i > 0 ? registers[i - 1] : null;
+        if (r.seq !== i)
+            reasons.push(`register ${i} is not at position ${i}`);
+        if (r.prev !== (i > 0 ? jcsHash(prev) : null))
+            reasons.push(`register ${i} does not name the previous register`);
+        if (i > 0 && isBodyRegister(prev) && !(ms(r.effective_from) > ms(prev.effective_from)))
+            reasons.push(`register ${i} does not take effect after the previous register`);
+        reasons.push(...boardSignedReasons(r, bl, "body register").map((x) => `register ${i}: ${x}`));
+    });
+    return { ok: reasons.length === 0, reasons };
+}
+/** Section 3: the register in force at `at` (the newest with effective_from at or before it), or null. */
+export function bodyRegisterAt(registers, at) {
+    let found = null;
+    for (const r of Array.isArray(registers) ? registers : [])
+        if (isBodyRegister(r) && ms(r.effective_from) <= ms(at))
+            found = r;
+    return found;
+}
+/** Section 3: the DIDs the register in force at `at` lists, accredited at `at` (and, given, for that profile and level). */
+export function trustedBodiesAt(registers, at, scope = {}) {
+    const r = bodyRegisterAt(registers, at);
+    return (r?.bodies ?? []).filter((b) => bodyCovers(b, at, scope).length === 0).map((b) => b.did);
+}
+function bodyCovers(b, at, scope) {
+    const out = [];
+    if (!(ms(b.valid_until) >= ms(at)))
+        out.push("the certification body's accreditation had expired when the certificate was issued");
+    if (scope.profile !== undefined) {
+        const s = b.scope.find((e) => e.profile === scope.profile);
+        if (!s || !s.levels.includes(scope.level))
+            out.push(`the certification body's accreditation does not cover profile ${scope.profile} at level ${String(scope.level)}`);
+    }
+    return out;
+}
+/**
+ * Section 3: the trusted bodies for a Level 3 certificate's audit from the register in force when
+ * it was issued, and the reasons the audit's body is not one of them.
+ */
+export function registerTrust(cert, auditBody, opts) {
+    const authority = opts.schemeLog !== undefined ? schemeAuthority(opts.schemeLog, opts.owner, { "certify.board": opts.boards, "certify.body-register": opts.registers }) : null;
+    const reasons = [...(authority ? authority.reasons : verifyBodyRegisterLog(opts.registers, opts.boards, { owner: opts.owner }).reasons)];
+    const at = String(cert?.issued_at);
+    const r = reasons.length === 0 ? bodyRegisterAt(opts.registers.filter(x => !authority?.canceled.size || !authority.canceled.has(jcsHash(x))), at) : null;
+    if (reasons.length === 0 && !r)
+        reasons.push("no body register was in force when the certificate was issued");
+    const b = r?.bodies.find((x) => x.did === auditBody);
+    const claim = isObj(cert?.claim) ? cert.claim : {};
+    const covers = b ? bodyCovers(b, at, { profile: String(claim.profile), level: claim.level }) : [];
+    reasons.push(...covers);
+    return { trusted: b && covers.length === 0 ? [b.did] : [], reasons };
+}

package/dist/rotation.d.ts

@@ -0,0 +1,49 @@
+import { type Signer } from "./signer.ts";
+export interface SuiteRef {
+    id: string;
+    version: number;
+}
+export interface Rotation {
+    v: 1 | 2;
+    type: "certify.suite-rotation";
+    issuer: string;
+    seq: number;
+    prev: string | null;
+    active_from: string;
+    suites: SuiteRef[];
+    profiles?: string[];
+    issued_at: string;
+    signer: string;
+    sig: string;
+}
+export interface RotationInput {
+    seq: number;
+    prev: string | null;
+    activeFrom: string;
+    suites: readonly SuiteRef[];
+    issuedAt: string;
+    profiles?: readonly string[];
+}
+/** Sign a rotation record as the lab issuer. `suites` is sorted here. */
+export declare function buildRotation(fields: RotationInput, signer: Signer): Promise<Rotation>;
+export interface RotationCheck {
+    ok: boolean;
+    reasons: string[];
+}
+/**
+ * Section 6.2: a rotation log is valid when every record is well formed and signed by `issuer`,
+ * `seq` counts from 0 with no gap, each `prev` is the hash of the record before, and neither
+ * `issued_at` nor per-lane `active_from` goes backwards.
+ */
+export declare function verifyRotationLog(log: readonly unknown[], opts: {
+    issuer: string;
+}): RotationCheck;
+/** Exact-profile override if effective, else global fallback; no profile selects global only. */
+export declare function activeRotation<T extends {
+    seq: number;
+    active_from: string;
+    v?: number;
+    profiles?: readonly string[];
+}>(log: readonly T[], at: string, profile?: string): T | null;
+/** Standalone integrity validation; callers must separately authenticate the issuer policy. */
+export declare function verifyRotationRecord(value: unknown): RotationCheck;

package/dist/rotation.js

@@ -0,0 +1,124 @@
+// spec/suites.md section 6: the suite rotation log. Each record names the held-out suite and
+// scenario library versions plans draw from, from `active_from` on; signed by the lab issuer,
+// chained by `prev`, append only.
+import { jcsHash, verifySignedObject } from "@zanii/core";
+import { isDid, isInt, isIso, isObj, isSha, ms, SLUG } from "./shared.js";
+import { signerDid, signWith } from "./signer.js";
+import { withinVerificationBudget } from "./verification-bounds.js";
+/** The section 6.1 field rules; the first broken rule, or null. `suites` must already be sorted. */
+function fieldError(r) {
+    if (r.v === 2) {
+        const scopes = r.profiles;
+        if (!Array.isArray(scopes) || scopes.length < 1 || scopes.length > 64 || !scopes.every(p => typeof p === "string" && p === p.trim() && p.length <= 160 && /^[a-z0-9][a-z0-9-]*\/[1-9][0-9]{0,6}$/.test(p) && Number(p.split("/")[1]) <= 1000000) || scopes.some((p, i) => i > 0 && !(scopes[i - 1] < p)))
+            return "profiles must list 1 to 64 sorted distinct exact profile/version references";
+    }
+    if (!isDid(r.issuer))
+        return "issuer must be a did:key";
+    if (!isInt(r.seq, 0, 1_000_000_000))
+        return "seq must be an integer from 0";
+    if (r.seq === 0 ? r.prev !== null : !isSha(r.prev))
+        return "prev must be null at seq 0 and the previous record's hash after";
+    if (!isIso(r.active_from) || !isIso(r.issued_at))
+        return "active_from and issued_at must be ISO UTC timestamps";
+    if (ms(r.active_from) < ms(r.issued_at))
+        return "active_from must not be before issued_at";
+    const s = r.suites;
+    if (!Array.isArray(s) || s.length < 1 || s.length > 200)
+        return "suites must list 1 to 200 suites";
+    for (const x of s)
+        if (!isObj(x) || Object.keys(x).length !== 2 || typeof x.id !== "string" || !SLUG.test(x.id) || !isInt(x.version, 1, 1_000_000))
+            return "each suite is {id, version}";
+    const ids = s.map((x) => x.id);
+    for (let i = 1; i < ids.length; i++)
+        if (!(ids[i - 1] < ids[i]))
+            return "suites must be sorted by id and distinct";
+    return null;
+}
+/** Sign a rotation record as the lab issuer. `suites` is sorted here. */
+export async function buildRotation(fields, signer) {
+    const unsigned = {
+        v: fields.profiles === undefined ? 1 : 2,
+        type: "certify.suite-rotation",
+        issuer: signerDid(signer),
+        seq: fields.seq,
+        prev: fields.prev,
+        active_from: fields.activeFrom,
+        suites: Array.isArray(fields.suites)
+            ? [...fields.suites].map((x) => ({ id: x.id, version: x.version })).sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+            : fields.suites,
+        issued_at: fields.issuedAt,
+        ...(fields.profiles === undefined ? {} : { profiles: [...fields.profiles].sort() }),
+    };
+    const err = fieldError(unsigned);
+    if (err)
+        throw new Error(err);
+    return signWith(unsigned, signer);
+}
+/**
+ * Section 6.2: a rotation log is valid when every record is well formed and signed by `issuer`,
+ * `seq` counts from 0 with no gap, each `prev` is the hash of the record before, and neither
+ * `issued_at` nor per-lane `active_from` goes backwards.
+ */
+export function verifyRotationLog(log, opts) {
+    if (!Array.isArray(log) || log.length > 10000 || !withinVerificationBudget(log, { maxBytes: 64 * 1024 * 1024, maxDepth: 8, maxNodes: 1000000 }))
+        return { ok: false, reasons: ["rotation history exceeds its verification budget"] };
+    const reasons = [];
+    let prev = null;
+    const lanes = new Map();
+    log.forEach((x, i) => {
+        const r = isObj(x) ? x : {};
+        const at = `record ${i}`;
+        if ((r.v !== 1 && r.v !== 2) || r.type !== "certify.suite-rotation" || Object.keys(r).length !== (r.v === 2 ? 11 : 10) || (r.v === 1 && "profiles" in r)) {
+            reasons.push(`${at}: not a suite rotation (v1)`);
+            prev = r;
+            return;
+        }
+        if (!verifySignedObject(r) || r.signer !== r.issuer)
+            reasons.push(`${at}: bad signature`);
+        if (r.issuer !== opts.issuer)
+            reasons.push(`${at}: not signed by the lab issuer`);
+        const err = fieldError(r);
+        if (err)
+            reasons.push(`${at}: ${err}`);
+        if (r.seq !== i)
+            reasons.push(`${at}: seq is not ${i}`);
+        if (prev) {
+            if (r.prev !== jcsHash(prev))
+                reasons.push(`${at}: prev is not the hash of the record before`);
+            if (ms(r.issued_at) < ms(prev.issued_at))
+                reasons.push(`${at}: issued_at or active_from goes backwards`);
+        }
+        const scopes = r.v === 2 && Array.isArray(r.profiles) ? r.profiles : ["*"];
+        if (scopes.some(scope => lanes.has(String(scope)) && ms(r.active_from) < lanes.get(String(scope))))
+            reasons.push(`${at}: issued_at or active_from goes backwards`);
+        for (const scope of scopes)
+            lanes.set(String(scope), ms(r.active_from));
+        prev = r;
+    });
+    return { ok: reasons.length === 0, reasons };
+}
+/** Exact-profile override if effective, else global fallback; no profile selects global only. */
+export function activeRotation(log, at, profile) {
+    let best = null, scoped = null;
+    for (const r of log)
+        if (ms(r.active_from) <= ms(at)) {
+            if (r.v === 2) {
+                if (profile && r.profiles?.includes(profile) && (!scoped || r.seq > scoped.seq))
+                    scoped = r;
+            }
+            else if (!best || r.seq > best.seq)
+                best = r;
+        }
+    return scoped ?? best;
+}
+/** Standalone integrity validation; callers must separately authenticate the issuer policy. */
+export function verifyRotationRecord(value) {
+    if (!withinVerificationBudget(value, { maxBytes: 65536, maxDepth: 6, maxNodes: 2000 }))
+        return { ok: false, reasons: ["rotation record exceeds its verification budget"] };
+    if (!isObj(value) || (value.v !== 1 && value.v !== 2) || value.type !== "certify.suite-rotation" || Object.keys(value).length !== (value.v === 2 ? 11 : 10) || (value.v === 1 && "profiles" in value))
+        return { ok: false, reasons: ["invalid suite rotation format"] };
+    const err = fieldError(value), reasons = err ? [err] : [];
+    if (value.signer !== value.issuer || !verifySignedObject(value))
+        reasons.push("bad rotation signature");
+    return { ok: reasons.length === 0, reasons };
+}

package/dist/royalty-reconciliation.d.ts

@@ -0,0 +1,24 @@
+import { type SignedTreeHead } from "@zanii/core";
+import { type Credential } from "@zanii/credentials";
+import { type LicenceOwnerHistoryPolicy } from "./licence-owner.ts";
+export interface RoyaltyFeedOptions {
+    owner: string;
+    licence: unknown;
+    pages: readonly unknown[];
+    issuers: readonly string[];
+    checkpoint: SignedTreeHead;
+    certificates: readonly Credential[];
+    now: string;
+    maxCheckpointAgeSeconds: number;
+    /** Proposal accounting only; does not imply owner acceptance. Defaults false. */
+    allowUncountersigned?: boolean;
+    ownerHistory?: LicenceOwnerHistoryPolicy;
+}
+export interface RoyaltyFeedCheck {
+    ok: boolean;
+    reasons: string[];
+    expected: string[];
+    missingEvidence: string[];
+}
+/** Reconcile only authenticated, complete supplied history; status `since` never substitutes for signed issuance time. */
+export declare function reconcileRoyaltyStatementFeed(statement: unknown, options: RoyaltyFeedOptions): RoyaltyFeedCheck;

package/dist/royalty-reconciliation.js

@@ -0,0 +1,88 @@
+import { jcsHash, publicKeyFromDid } from "@zanii/core";
+import { credentialHash } from "@zanii/credentials";
+import { claimReasons } from "./certificate.js";
+import { verifyFeed } from "./federation.js";
+import { verifyLicence, verifyRoyaltyStatement } from "./licence.js";
+import { verifyLicenceWithOwnerHistory } from "./licence-owner.js";
+import { isInt, isIso, isObj, ms } from "./shared.js";
+import { signatureOk } from "./signer.js";
+import { withinVerificationBudget } from "./verification-bounds.js";
+/** Reconcile only authenticated, complete supplied history; status `since` never substitutes for signed issuance time. */
+export function reconcileRoyaltyStatementFeed(statement, options) {
+    const denied = (reasons) => ({ ok: false, reasons, expected: [], missingEvidence: [] });
+    if (!withinVerificationBudget({ statement, options }))
+        return denied(["royalty reconciliation evidence exceeds the JSON budget"]);
+    if (!isObj(options) || ![8, 9, 10].includes(Object.keys(options).length) || ["owner", "licence", "pages", "issuers", "checkpoint", "certificates", "now", "maxCheckpointAgeSeconds"].some(k => !Object.hasOwn(options, k))
+        || Object.keys(options).some(k => !["owner", "licence", "pages", "issuers", "checkpoint", "certificates", "now", "maxCheckpointAgeSeconds", "allowUncountersigned", "ownerHistory"].includes(k))
+        || (options.ownerHistory !== undefined && !isObj(options.ownerHistory))
+        || (Object.hasOwn(options, "allowUncountersigned") && typeof options.allowUncountersigned !== "boolean") || !Array.isArray(options.pages) || options.pages.length < 1 || options.pages.length > 1000
+        || !Array.isArray(options.certificates) || options.certificates.length > 50_000 || !Array.isArray(options.issuers) || options.issuers.length < 1 || options.issuers.length > 64
+        || !options.issuers.every((d) => typeof d === "string" && publicKeyFromDid(d)) || !isIso(options.now) || !isInt(options.maxCheckpointAgeSeconds, 1, 31_536_000))
+        return denied(["invalid royalty reconciliation policy or evidence bounds"]);
+    let count = 0;
+    for (const page of options.pages) {
+        if (!isObj(page) || !Array.isArray(page.entries) || (count += page.entries.length) > 50_000)
+            return denied(["royalty reconciliation feed exceeds 50000 entries"]);
+    }
+    const ownerPolicy = options.ownerHistory !== undefined ? { ownerHistory: options.ownerHistory } : {};
+    const checkedLicence = options.ownerHistory !== undefined ? verifyLicenceWithOwnerHistory(options.licence, { root: options.owner, ...options.ownerHistory }) : verifyLicence(options.licence, { owner: options.owner });
+    const checkedStatement = verifyRoyaltyStatement(statement, { owner: options.owner, licence: options.licence, ...ownerPolicy });
+    const statementReasons = (reasons) => options.allowUncountersigned === true ? reasons.filter(r => r !== "royalty statement is not countersigned by the scheme owner") : reasons;
+    const feed = verifyFeed(options.pages, { issuers: options.issuers, ...(isObj(options.checkpoint) ? { checkpoint: options.checkpoint } : {}) });
+    const reasons = [...checkedLicence.reasons, ...statementReasons(checkedStatement.reasons), ...feed.reasons];
+    for (const page of options.pages)
+        if (isObj(page) && Array.isArray(page.entries) && page.entries.some((e) => isObj(e) && ms(e.since) > ms(page.issued_at)))
+            reasons.push("royalty feed status time is after its page");
+    if (!isObj(options.licence) || !options.issuers.includes(String(options.licence.licensee)))
+        reasons.push("licence licensee is not trusted for this feed");
+    const cp = options.checkpoint, s = isObj(statement) ? statement : {}, period = isObj(s.period) ? s.period : {};
+    if (!isObj(cp) || !options.issuers.includes(String(cp.log_id)))
+        reasons.push("royalty feed checkpoint is not signed by a trusted instance issuer");
+    const last = options.pages.at(-1);
+    if (!isObj(cp) || !isIso(cp.ts) || ms(cp.ts) > ms(options.now) || ms(options.now) - ms(cp.ts) >= options.maxCheckpointAgeSeconds * 1000)
+        reasons.push("royalty feed checkpoint is missing, stale or in the future");
+    if (!isIso(period.until) || !isObj(last) || !isIso(last.issued_at) || ms(last.issued_at) < ms(period.until) || ms(cp?.ts) < ms(last.issued_at) || ms(last.issued_at) > ms(options.now))
+        reasons.push("royalty feed does not cover the complete reporting period");
+    if (reasons.length)
+        return denied([...new Set(reasons)]);
+    const licenceHash = jcsHash(options.licence), docs = new Map(), missingEvidence = [], expected = [];
+    for (const cert of options.certificates) {
+        if (!isObj(cert) || cert.v !== 1 || cert.type !== "credential" || typeof cert.issuer !== "string" || !options.issuers.includes(cert.issuer) || !isIso(cert.issued_at) || !isObj(cert.claim)
+            || !isIso(cert.exp) || ms(cert.issued_at) > ms(options.now) || claimReasons(cert).length)
+            return denied(["invalid signed original certificate evidence"]);
+        const { sig, ...unsigned } = cert;
+        if (!signatureOk(unsigned, sig, cert.issuer))
+            return denied(["invalid signed original certificate evidence"]);
+        const original = cert;
+        const hash = credentialHash(original);
+        if (docs.has(hash))
+            return denied(["duplicate original certificate evidence"]);
+        docs.set(hash, original);
+    }
+    for (const entry of feed.entries) {
+        if (entry.licence !== licenceHash)
+            continue;
+        const cert = docs.get(entry.certificate);
+        if (!cert) {
+            missingEvidence.push(entry.certificate);
+            continue;
+        }
+        const claim = cert.claim;
+        if (claim.licence !== licenceHash || claim.profile !== entry.profile || claim.level !== entry.level)
+            reasons.push(`original certificate does not match feed entry ${entry.certificate}`);
+        if (ms(cert.issued_at) > ms(entry.since) || ms(cert.issued_at) > ms(last.issued_at))
+            reasons.push(`original certificate issuance is after its feed state ${entry.certificate}`);
+        if (ms(cert.issued_at) >= ms(period.from) && ms(cert.issued_at) < ms(period.until))
+            expected.push(entry.certificate);
+    }
+    const feedHashes = new Set(feed.entries.map((e) => e.certificate));
+    for (const [hash, cert] of docs)
+        if (isObj(cert.claim) && cert.claim.licence === licenceHash && !feedHashes.has(hash))
+            reasons.push(`original certificate is missing from the feed ${hash}`);
+    if (missingEvidence.length)
+        reasons.push("signed original certificates are missing for the licence feed");
+    expected.sort();
+    missingEvidence.sort();
+    reasons.push(...statementReasons(verifyRoyaltyStatement(statement, { owner: options.owner, licence: options.licence, certificates: expected, ...ownerPolicy }).reasons));
+    return { ok: reasons.length === 0, reasons: [...new Set(reasons)], expected, missingEvidence };
+}

package/dist/runtime-client.d.ts

@@ -0,0 +1,40 @@
+import { type RuntimeNitroBinding } from "./runtime-nitro.ts";
+import { type RuntimeApproval, type RuntimePolicy } from "./runtime.ts";
+import { type Signer } from "./signer.ts";
+export interface RuntimeAttestationBinding extends RuntimeNitroBinding {
+    /** The Nitro nonce is the authority's challenge, not the challenge request's replay nonce. */
+    nonce: string;
+    /** Exact Ed25519 SubjectPublicKeyInfo DER (44 bytes). */
+    publicKey: Uint8Array;
+    /** UTF-8 bytes of runtimeNitroBindingHash, including its sha256: prefix. */
+    userData: Uint8Array;
+}
+export interface RuntimeReporterOptions {
+    authority: string;
+    issuers: readonly string[];
+    approval: RuntimeApproval;
+    policy: RuntimePolicy;
+    deployment: string;
+    signer: Signer;
+    attest: (binding: RuntimeAttestationBinding) => Promise<Uint8Array>;
+    fetch?: typeof fetch;
+    /** Optional agent-bound admission credential, separate from workload proof. */
+    transportKey?: string;
+    clock?: () => number;
+    intervalMs?: number;
+    onResult?: (result: RuntimeReportResult | {
+        accepted: false;
+        error: Error;
+    }) => void | Promise<void>;
+}
+export interface RuntimeReportResult {
+    accepted: true;
+    deployment: string;
+    evidence_until: string;
+}
+/** One reporter has at most one underlying operation, including an uncancellable attester after timeout. */
+export declare function createRuntimeReporter(options: RuntimeReporterOptions): {
+    send(): Promise<RuntimeReportResult>;
+    start(): void;
+    stop(): Promise<void>;
+};