@zanii/blackbox 0.2.0 → 0.4.0

package/dist/analysis/reference.d.ts

@@ -0,0 +1,49 @@
+import type { Fact } from "./grounding.ts";
+export interface ReferenceFact {
+    id: string;
+    /** Terms that name what the fact is about (`SOFA-221`, `refund`, `استرداد`): one of them must be in
+     * the answer's sentence for the fact to apply. */
+    about: string[];
+    kind: "money" | "percent" | "quantity" | "date" | "text";
+    /** Canonical (`1250.5`, `20261015`); absent for `text`. */
+    value?: string;
+    currency?: string;
+    unit?: string;
+    text?: string;
+    source?: string;
+}
+export interface ReferencePack {
+    id: string;
+    version: string;
+    tenant?: string;
+    title?: string;
+    facts: ReferenceFact[];
+    /** `sha256:` of the pack's RFC 8785 JSON as loaded. */
+    hash: string;
+}
+/** spec/findings.md §10: the packs in a reference file, checked; throws with the first problem. */
+export declare function loadReferencePacks(bytes: Uint8Array): ReferencePack[];
+/** The packs a session's tenant sees: its own, and those for everyone. */
+export declare function packsFor(packs: readonly ReferencePack[], tenant: string | undefined): ReferencePack[];
+export type ReferenceVerdict = {
+    status: "grounded";
+    pack: ReferencePack;
+    fact: ReferenceFact;
+} | {
+    status: "contradicted";
+    pack: ReferencePack;
+    fact: ReferenceFact;
+} | null;
+/**
+ * §10: what the packs say about one fact of an answer. The pack facts that apply are those of the
+ * same kind with an `about` term in the fact's sentence. Grounded when one of them has its value;
+ * contradicted when some apply and none has it; null when none applies.
+ */
+export declare function checkAgainstPacks(text: string, f: Fact, packs: readonly ReferencePack[]): ReferenceVerdict;
+/** §10: the text facts an answer touches (an `about` term anywhere in it), for a grounding service. */
+export declare function referenceContext(text: string, packs: readonly ReferencePack[]): Array<{
+    pack: string;
+    id: string;
+    text: string;
+    source?: string;
+}>;

package/dist/analysis/reference.js

@@ -0,0 +1,164 @@
+// Reference packs (spec/findings.md §10, H4): the facts an organisation owns (prices, fees, rules,
+// deadlines, limits, terms), loaded once and checked against every answer, even when the agent
+// called no tool. Any industry: a pack is data, and a tenant can have its own. Mirrors
+// sdks/python/src/zanii_blackbox/analysis/reference.py; pinned by spec/vectors/reference.json.
+import { createHash } from "node:crypto";
+import { canonical } from "../reconcile/shared.js";
+import { canonicalNumber, normaliseValue, western } from "./hallucination.js";
+const KINDS = new Set(["money", "percent", "quantity", "date", "text"]);
+const NUMERIC = /^[0-9]{1,3}(?:,[0-9]{3})+(?:\.[0-9]+)?$|^[0-9]+(?:\.[0-9]+)?$/;
+const DATE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
+const str = (v, max) => typeof v === "string" && v.length >= 1 && v.length <= max;
+/** spec/findings.md §10: the packs in a reference file, checked; throws with the first problem. */
+export function loadReferencePacks(bytes) {
+    let doc;
+    try {
+        doc = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        throw new Error("the reference file isn't JSON");
+    }
+    const packs = doc?.packs;
+    if (!Array.isArray(packs) || packs.length < 1 || packs.length > 100)
+        throw new Error("packs must be a list of 1-100 packs");
+    const ids = new Set();
+    return packs.map((p, i) => {
+        const at = `packs[${i}]`;
+        if (typeof p !== "object" || p === null || Array.isArray(p))
+            throw new Error(`${at} must be an object`);
+        const o = p;
+        if (typeof o.id !== "string" || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(o.id))
+            throw new Error(`${at}.id must be 1-64 of a-z 0-9 -`);
+        const key = `${o.tenant ?? ""}\u0000${o.id}`;
+        if (ids.has(key))
+            throw new Error(`${at}.id ${o.id} is there twice`);
+        ids.add(key);
+        if (!str(o.version, 64))
+            throw new Error(`${at}.version must be 1-64 characters`);
+        if (o.tenant !== undefined && !str(o.tenant, 128))
+            throw new Error(`${at}.tenant must be 1-128 characters`);
+        if (o.title !== undefined && !str(o.title, 200))
+            throw new Error(`${at}.title must be 1-200 characters`);
+        if (!Array.isArray(o.facts) || o.facts.length < 1 || o.facts.length > 10_000)
+            throw new Error(`${at}.facts must be a list of 1-10,000 facts`);
+        const factIds = new Set();
+        const facts = o.facts.map((f, j) => checkFact(f, `${at}.facts[${j}]`, factIds));
+        const pack = {
+            id: o.id,
+            version: o.version,
+            ...(o.tenant !== undefined ? { tenant: o.tenant } : {}),
+            ...(o.title !== undefined ? { title: o.title } : {}),
+            facts,
+        };
+        return {
+            ...pack,
+            hash: `sha256:${createHash("sha256").update(canonical(pack)).digest("hex")}`,
+        };
+    });
+}
+function checkFact(f, at, ids) {
+    if (typeof f !== "object" || f === null || Array.isArray(f))
+        throw new Error(`${at} must be an object`);
+    const o = f;
+    if (typeof o.id !== "string" || !/^[A-Za-z0-9._-]{1,128}$/.test(o.id))
+        throw new Error(`${at}.id must be 1-128 of A-Z a-z 0-9 . _ -`);
+    if (ids.has(o.id))
+        throw new Error(`${at}.id ${o.id} is there twice`);
+    ids.add(o.id);
+    if (!Array.isArray(o.about) ||
+        o.about.length < 1 ||
+        o.about.length > 20 ||
+        !o.about.every((a) => str(a, 100)))
+        throw new Error(`${at}.about must be 1-20 terms of 1-100 characters`);
+    if (typeof o.kind !== "string" || !KINDS.has(o.kind))
+        throw new Error(`${at}.kind must be money, percent, quantity, date or text`);
+    for (const k of ["currency", "unit"])
+        if (o[k] !== undefined && !str(o[k], 32))
+            throw new Error(`${at}.${k} must be 1-32 characters`);
+    if (o.text !== undefined && !str(o.text, 2000))
+        throw new Error(`${at}.text must be 1-2,000 characters`);
+    if (o.source !== undefined && !str(o.source, 500))
+        throw new Error(`${at}.source must be 1-500 characters`);
+    let value;
+    if (o.kind === "text") {
+        if (o.text === undefined)
+            throw new Error(`${at}: a text fact needs text`);
+    }
+    else {
+        const v = typeof o.value === "number" ? String(o.value) : o.value;
+        if (typeof v !== "string")
+            throw new Error(`${at}.value is required`);
+        if (o.kind === "date") {
+            if (!DATE.test(v))
+                throw new Error(`${at}.value must be a date (YYYY-MM-DD)`);
+            value = normaliseValue(v);
+        }
+        else {
+            if (!NUMERIC.test(v))
+                throw new Error(`${at}.value must be a number`);
+            value = canonicalNumber(v);
+        }
+    }
+    return {
+        id: o.id,
+        about: o.about,
+        kind: o.kind,
+        ...(value !== undefined ? { value } : {}),
+        ...(o.currency !== undefined ? { currency: o.currency } : {}),
+        ...(o.unit !== undefined ? { unit: o.unit } : {}),
+        ...(o.text !== undefined ? { text: o.text } : {}),
+        ...(o.source !== undefined ? { source: o.source } : {}),
+    };
+}
+/** The packs a session's tenant sees: its own, and those for everyone. */
+export function packsFor(packs, tenant) {
+    return packs.filter((p) => p.tenant === undefined || p.tenant === tenant);
+}
+const norm = (s) => western(s).toLowerCase();
+/** The sentence around [at, end) in `text`. */
+function sentenceAt(text, at, end) {
+    let a = at;
+    while (a > 0 && !".!?؟\n".includes(text[a - 1]))
+        a--;
+    let b = end;
+    // a decimal point between digits doesn't end a sentence
+    while (b < text.length &&
+        !(".!?؟\n".includes(text[b]) && !/[0-9]/.test(text[b + 1] ?? "")))
+        b++;
+    return text.slice(a, b);
+}
+/**
+ * §10: what the packs say about one fact of an answer. The pack facts that apply are those of the
+ * same kind with an `about` term in the fact's sentence. Grounded when one of them has its value;
+ * contradicted when some apply and none has it; null when none applies.
+ */
+export function checkAgainstPacks(text, f, packs) {
+    if (f.kind !== "money" && f.kind !== "percent" && f.kind !== "quantity" && f.kind !== "date")
+        return null;
+    const sentence = norm(sentenceAt(text, f.at, f.end));
+    let first = null;
+    for (const pack of packs)
+        for (const fact of pack.facts) {
+            if (fact.kind !== f.kind || !fact.about.some((t) => sentence.includes(norm(t))))
+                continue;
+            if (fact.value === f.value)
+                return { status: "grounded", pack, fact };
+            first ??= { pack, fact };
+        }
+    return first ? { status: "contradicted", ...first } : null;
+}
+/** §10: the text facts an answer touches (an `about` term anywhere in it), for a grounding service. */
+export function referenceContext(text, packs) {
+    const t = norm(text);
+    const out = [];
+    for (const pack of packs)
+        for (const fact of pack.facts)
+            if (fact.text !== undefined && fact.about.some((a) => t.includes(norm(a))) && out.length < 50)
+                out.push({
+                    pack: pack.id,
+                    id: fact.id,
+                    text: fact.text,
+                    ...(fact.source ? { source: fact.source } : {}),
+                });
+    return out;
+}

package/dist/analysis/taxonomy.d.ts

@@ -0,0 +1,18 @@
+export declare const OWASP_ASI: Readonly<Record<string, string>>;
+export declare const MITRE_ATLAS: Readonly<Record<string, string>>;
+export declare const TAXONOMY: Readonly<Record<string, {
+    owasp?: readonly string[];
+    atlas?: readonly string[];
+}>>;
+export interface Taxonomy {
+    owasp: Array<{
+        id: string;
+        title: string;
+    }>;
+    atlas: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+/** The OWASP ASI and MITRE ATLAS entries a finding code maps to; empty lists when none fits. */
+export declare function taxonomyOf(code: string): Taxonomy;

package/dist/analysis/taxonomy.js

@@ -0,0 +1,66 @@
+// Threat taxonomy per finding code (spec/findings.md §7, spec/faults/taxonomy-v1.json): OWASP Top 10
+// for Agentic Applications 2026 and MITRE ATLAS technique ids. A test checks this table matches the
+// file exactly. Mirrors analysis/taxonomy.py.
+export const OWASP_ASI = {
+    ASI01: "Agent Goal Hijack",
+    ASI02: "Tool Misuse & Exploitation",
+    ASI03: "Identity & Privilege Abuse",
+    ASI04: "Agentic Supply Chain Vulnerabilities",
+    ASI05: "Unexpected Code Execution (RCE)",
+    ASI06: "Memory & Context Poisoning",
+    ASI07: "Insecure Inter-Agent Communication",
+    ASI08: "Cascading Failures",
+    ASI09: "Human-Agent Trust Exploitation",
+    ASI10: "Rogue Agents",
+};
+export const MITRE_ATLAS = {
+    "AML.T0034": "Cost Harvesting",
+    "AML.T0034.000": "Cost Harvesting: Excessive Queries",
+    "AML.T0034.001": "Cost Harvesting: Resource-Intensive Queries",
+    "AML.T0034.002": "Cost Harvesting: Agentic Resource Consumption",
+    "AML.T0053": "AI Agent Tool Invocation",
+    "AML.T0057": "LLM Data Leakage",
+    "AML.T0080.000": "AI Agent Context Poisoning: Memory",
+    "AML.T0086": "Exfiltration via AI Agent Tool Invocation",
+    "AML.T0091.000": "Application Access Token",
+    "AML.T0099": "AI Agent Tool Data Poisoning",
+    "AML.T0110.002": "AI Agent Tool Poisoning: Runtime Response",
+};
+export const TAXONOMY = {
+    ABNORMAL_RUN: { owasp: ["ASI10"] },
+    ALTERED: { owasp: ["ASI10"] },
+    AUTOMATION_SURPRISE: { owasp: ["ASI10"] },
+    BYPASS: { owasp: ["ASI10"] },
+    CALL_LIMIT: { atlas: ["AML.T0034", "AML.T0034.000"] },
+    CLAIM_UNVERIFIED: { owasp: ["ASI09"] },
+    D1_REPEAT_CALL: { atlas: ["AML.T0034.002"] },
+    D2_ACTION_LOOP: { atlas: ["AML.T0034.002"] },
+    D4_CONTEXT_BLOAT: { atlas: ["AML.T0034.001"] },
+    D6_SPEND: { atlas: ["AML.T0034", "AML.T0034.002"] },
+    DATA_CANARY_TRIPPED: { owasp: ["ASI02"], atlas: ["AML.T0086", "AML.T0057"] },
+    DATA_TO_UNAPPROVED_DESTINATION: { owasp: ["ASI02"], atlas: ["AML.T0086"] },
+    EXTRA_LOCAL: { owasp: ["ASI10"] },
+    FALSE_CLAIM: { owasp: ["ASI09", "ASI10"] },
+    FALSE_SUCCESS: { owasp: ["ASI09", "ASI10"] },
+    MISSING_LOCAL: { owasp: ["ASI10"] },
+    PLAN_DEVIATION: { owasp: ["ASI01", "ASI10"] },
+    PLAN_VIOLATION: { owasp: ["ASI02", "ASI10"], atlas: ["AML.T0053"] },
+    POLICY_AUDIT: { owasp: ["ASI02"], atlas: ["AML.T0053"] },
+    POLICY_DENIED: { owasp: ["ASI02"], atlas: ["AML.T0053"] },
+    POLICY_VIOLATION: { owasp: ["ASI02"], atlas: ["AML.T0053"] },
+    RETRY_STORM: { owasp: ["ASI08"] },
+    REVOKED_MEMORY_READ: { owasp: ["ASI06"], atlas: ["AML.T0080.000"] },
+    STERILE_VIOLATION: { owasp: ["ASI02", "ASI10"], atlas: ["AML.T0053"] },
+    TOKEN_MISUSE: { owasp: ["ASI03"], atlas: ["AML.T0091.000", "AML.T0086"] },
+    TOOL_CHANGED: { owasp: ["ASI04"], atlas: ["AML.T0110.002"] },
+    TOOL_OUTPUT_MISMATCH: { owasp: ["ASI04", "ASI06"], atlas: ["AML.T0110.002", "AML.T0099"] },
+    TOOL_WITNESS_INVALID: { owasp: ["ASI04"], atlas: ["AML.T0110.002"] },
+};
+/** The OWASP ASI and MITRE ATLAS entries a finding code maps to; empty lists when none fits. */
+export function taxonomyOf(code) {
+    const t = TAXONOMY[code];
+    return {
+        owasp: (t?.owasp ?? []).map((id) => ({ id, title: OWASP_ASI[id] ?? id })),
+        atlas: (t?.atlas ?? []).map((id) => ({ id, name: MITRE_ATLAS[id] ?? id })),
+    };
+}

package/dist/approvals/index.d.ts

@@ -1,3 +1,7 @@
+import { createConfirmation } from "@zanii/core";
+/** spec/approvals.md §2: what an approval's arguments are, `sha256:<hex>` of their canonical JSON
+ * (keys sorted, no whitespace). The approver sees these; the run must use them. */
+export declare function argsHash(args: unknown): string;
 export interface ApprovalFinding {
     code: "APPROVAL_REJECTED" | "APPROVAL_TIMEOUT";
     source: "approval";
@@ -9,3 +13,22 @@ export interface ApprovalFinding {
 }
 /** spec/approvals.md §3: a refused action (advisory), and one nobody confirmed in time (warning). */
 export declare function approvalFindings(lines: readonly string[]): ApprovalFinding[];
+/**
+ * spec/approvals.md §8: a person's yes as a Zanii action_confirmation, signed with the gateway's
+ * identity: over the hash of the event approved (the held call, or the approval request), at the
+ * decision's time. Deterministic. `error` when there is no approve decision.
+ */
+export declare function approvalConfirmation(lines: readonly string[], approvalId: string, gateway: {
+    did: string;
+    privateKey: Uint8Array;
+}): {
+    confirmation: ReturnType<typeof createConfirmation>;
+    decision_seq: number;
+    action_seq: number;
+    by: unknown;
+    person?: unknown;
+} | {
+    error: "not_found" | "not_approved";
+};
+/** spec/approvals.md §8: Zanii's check of an action_confirmation (the DID it names signed it). */
+export declare const verifyConfirmation: (c: unknown) => boolean;

package/dist/approvals/index.js

@@ -1,5 +1,16 @@
 // The two-person rule (spec/approvals.md): what the approval decisions say. Pure; mirrors
 // sdks/python/src/zanii_blackbox/approvals.py; pinned by spec/vectors/approvals.json.
+import { createHash } from "node:crypto";
+import { createConfirmation, verifyConfirmation as zaniiVerifyConfirmation } from "@zanii/core";
+import { canonical } from "../reconcile/shared.js";
+import { hashLine } from "../verify/envelope.js";
+/** spec/approvals.md §2: what an approval's arguments are, `sha256:<hex>` of their canonical JSON
+ * (keys sorted, no whitespace). The approver sees these; the run must use them. */
+export function argsHash(args) {
+    return `sha256:${createHash("sha256")
+        .update(canonical(args ?? null))
+        .digest("hex")}`;
+}
 /** spec/approvals.md §3: a refused action (advisory), and one nobody confirmed in time (warning). */
 export function approvalFindings(lines) {
     const out = [];
@@ -25,3 +36,40 @@ export function approvalFindings(lines) {
     }
     return out;
 }
+/**
+ * spec/approvals.md §8: a person's yes as a Zanii action_confirmation, signed with the gateway's
+ * identity: over the hash of the event approved (the held call, or the approval request), at the
+ * decision's time. Deterministic. `error` when there is no approve decision.
+ */
+export function approvalConfirmation(lines, approvalId, gateway) {
+    const events = lines.map((l) => JSON.parse(l));
+    const decision = events.find((e) => e.kind === "control" && e.meta.action === "approval" && e.meta.approval_id === approvalId);
+    if (!decision)
+        return { error: "not_found" };
+    if (decision.meta.decision !== "approve")
+        return { error: "not_approved" };
+    const request = events.find((e) => e.kind === "control" &&
+        e.meta.action === "approval_request" &&
+        e.meta.approval_id === approvalId);
+    const actionSeq = typeof decision.meta.call_seq === "number" ? decision.meta.call_seq : (request?.seq ?? -1);
+    const line = lines[actionSeq];
+    if (line === undefined)
+        return { error: "not_found" };
+    const confirmation = createConfirmation({ ownerId: gateway.did, actionHash: hashLine(line), confirmedAt: decision.ts }, gateway.privateKey);
+    return {
+        confirmation,
+        decision_seq: decision.seq,
+        action_seq: actionSeq,
+        by: decision.meta.by,
+        ...(decision.meta.person !== undefined ? { person: decision.meta.person } : {}),
+    };
+}
+/** spec/approvals.md §8: Zanii's check of an action_confirmation (the DID it names signed it). */
+export const verifyConfirmation = (c) => {
+    try {
+        return zaniiVerifyConfirmation(c);
+    }
+    catch {
+        return false;
+    }
+};

package/dist/archive/index.d.ts

@@ -0,0 +1,39 @@
+export interface ArchiveFile {
+    name: string;
+    sha256: string;
+    bytes: number;
+}
+export interface ArchiveManifest {
+    v: 1;
+    id: string;
+    created_at: string;
+    files: ArchiveFile[];
+    /** RFC 9162 root over leafHash(`<name> <sha256>`), in name order. */
+    root: string;
+    /** The log checkpoint (a signed note) when it was made, or null. */
+    checkpoint: string | null;
+    /** RFC 3161 TimeStampResps, base64, oldest first. */
+    timestamps: string[];
+}
+/** §2: one file's entry. Names are plain: 1-128 of [A-Za-z0-9._-]. */
+export declare function archiveEntry(name: string, data: Uint8Array): ArchiveFile;
+/** §2: the manifest, without timestamps, for these entries (unique names). */
+export declare function archiveManifest(id: string, createdAt: string, entries: readonly ArchiveFile[], checkpoint: string | null): ArchiveManifest;
+/** §3: what the `n`th timestamp stamps: SHA-256 of the manifest's core, then of that and the previous token. */
+export declare function archiveDigest(manifest: ArchiveManifest, n: number): Uint8Array;
+export interface ArchiveReport {
+    ok: boolean;
+    /** Each file's hash and size match; null when no files were given. */
+    files: boolean | null;
+    root: boolean;
+    /** Each timestamp's time, oldest first, while the chain holds. */
+    timestamps: string[];
+    problems: string[];
+}
+/**
+ * §4: checks a manifest offline: its root, each file given (by name), and the timestamp chain,
+ * each token against the digest it must stamp and `tsaRoots`.
+ */
+export declare function verifyArchive(manifest: ArchiveManifest, files: ReadonlyMap<string, Uint8Array> | null, options?: {
+    tsaRoots?: readonly string[];
+}): ArchiveReport;

package/dist/archive/index.js

@@ -0,0 +1,96 @@
+// Cold archives (spec/archive.md): a set of closed sessions' records, kept for years as plain JSONL
+// files with a manifest: each file's SHA-256, an RFC 9162 Merkle root over them, the log checkpoint
+// they sit under, and a chain of RFC 3161 timestamps. Each renewal stamps the manifest and the
+// previous token, so the evidence outlives the TSA's certificate and its algorithms (the RFC 4998
+// idea). Mirrors sdks/python/src/zanii_blackbox/archive.py.
+import { createHash } from "node:crypto";
+import { canonicalBytes } from "@zanii/core";
+import { verifyTimestamp } from "../timestamp/index.js";
+import { leafHash, merkleRoot } from "../transparency/index.js";
+const sha256 = (...parts) => {
+    const h = createHash("sha256");
+    for (const p of parts)
+        h.update(p);
+    return new Uint8Array(h.digest());
+};
+const hex = (b) => Buffer.from(b).toString("hex");
+const NAME = /^[A-Za-z0-9._-]{1,128}$/;
+/** §2: one file's entry. Names are plain: 1-128 of [A-Za-z0-9._-]. */
+export function archiveEntry(name, data) {
+    if (!NAME.test(name))
+        throw new Error(`an archive file name must be 1-128 of [A-Za-z0-9._-]: ${name}`);
+    return { name, sha256: hex(sha256(data)), bytes: data.length };
+}
+/** §2: the manifest, without timestamps, for these entries (unique names). */
+export function archiveManifest(id, createdAt, entries, checkpoint) {
+    const names = new Set(entries.map((f) => f.name));
+    if (names.size !== entries.length)
+        throw new Error("archive file names must be unique");
+    const listed = [...entries]
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+        .map((f) => ({ name: f.name, sha256: f.sha256, bytes: f.bytes }));
+    return {
+        v: 1,
+        id,
+        created_at: createdAt,
+        files: listed,
+        root: hex(merkleRoot(listed.map((f) => leafHash(Buffer.from(`${f.name} ${f.sha256}`, "utf8"))))),
+        checkpoint,
+        timestamps: [],
+    };
+}
+/** §3: what the `n`th timestamp stamps: SHA-256 of the manifest's core, then of that and the previous token. */
+export function archiveDigest(manifest, n) {
+    const { timestamps, ...core } = manifest;
+    const first = sha256(canonicalBytes(core));
+    if (n === 0)
+        return first;
+    const previous = timestamps[n - 1];
+    if (previous === undefined)
+        throw new Error(`the archive has no timestamp ${n - 1}`);
+    return sha256(first, Buffer.from(previous, "base64"));
+}
+/**
+ * §4: checks a manifest offline: its root, each file given (by name), and the timestamp chain,
+ * each token against the digest it must stamp and `tsaRoots`.
+ */
+export function verifyArchive(manifest, files, options = {}) {
+    const report = {
+        ok: false,
+        files: null,
+        root: false,
+        timestamps: [],
+        problems: [],
+    };
+    const leaves = manifest.files.map((f) => leafHash(Buffer.from(`${f.name} ${f.sha256}`, "utf8")));
+    report.root = leaves.length > 0 && hex(merkleRoot(leaves)) === manifest.root;
+    if (!report.root)
+        report.problems.push("the root isn't the files'");
+    if (files) {
+        const bad = manifest.files.filter((f) => {
+            const data = files.get(f.name);
+            return !data || data.length !== f.bytes || hex(sha256(data)) !== f.sha256;
+        });
+        report.files = bad.length === 0;
+        for (const f of bad)
+            report.problems.push(`${f.name} is missing or changed`);
+    }
+    let last = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < manifest.timestamps.length; i++) {
+        const t = verifyTimestamp(new Uint8Array(Buffer.from(manifest.timestamps[i], "base64")), {
+            digest: archiveDigest(manifest, i),
+            ...(options.tsaRoots ? { roots: options.tsaRoots } : {}),
+        });
+        const at = t.gen_time ? Date.parse(t.gen_time) : Number.NaN;
+        if (!t.ok || !t.gen_time || !(at >= last)) {
+            report.problems.push(`timestamp ${i} doesn't hold: ${t.problems.join("; ") || "out of order"}`);
+            break;
+        }
+        last = at;
+        report.timestamps.push(t.gen_time);
+    }
+    if (manifest.timestamps.length === 0)
+        report.problems.push("the archive has no timestamp");
+    report.ok = report.problems.length === 0;
+    return report;
+}

package/dist/archive/parquet.d.ts

@@ -0,0 +1,2 @@
+/** The archived events (session lines, in archive order) as one Parquet file. */
+export declare function archiveParquet(lines: readonly string[]): Uint8Array;