@zanii/blackbox 0.2.0 → 0.4.0

package/dist/federation/index.js

@@ -0,0 +1,102 @@
+// Witnessing and federation (spec/anchoring.md §12): the gateway as an independent witness that
+// co-signs the ledger's signed tree heads it checked, and gossip that turns a split view into an
+// equivocation proof (@zanii/witness, @zanii/federation). Pure; mirrors
+// sdks/python/src/zanii_blackbox/federation.py; pinned by spec/vectors/federation.json.
+import { createSTH, verifySTH } from "@zanii/core";
+const valid = (sth) => {
+    try {
+        return typeof sth === "object" && sth !== null && verifySTH(sth);
+    }
+    catch {
+        return false;
+    }
+};
+/** Zanii's witness co-signature over a signed tree head the caller has checked (signed, append-only). */
+export function cosignLedgerSth(sth, o) {
+    if (!valid(sth))
+        throw new Error("refusing to co-sign: the signed tree head doesn't verify");
+    const cosignature = createSTH({ logId: o.did, size: sth.size, root: sth.root, ts: sth.ts }, o.privateKey);
+    return { v: 1, witnessed_log_id: sth.log_id, cosignature };
+}
+/** Zanii's check: a valid co-signature over the same (size, root) of a valid tree head. */
+export function verifyLedgerCosignature(c, sth) {
+    const p = (c ?? {});
+    const cs = p.cosignature;
+    if (p.v !== 1 || !cs || typeof cs !== "object" || p.witnessed_log_id !== sth.log_id)
+        return false;
+    return valid(sth) && valid(cs) && cs.size === sth.size && cs.root === sth.root;
+}
+/** Zanii's equivocation proof: one log key, one size, two roots. Throws unless it really is one. */
+export function buildEquivocationProof(a, b) {
+    if (a.log_id !== b.log_id)
+        throw new Error("not equivocation: different logs");
+    if (a.size !== b.size)
+        throw new Error("not equivocation: different tree sizes (could be honest growth)");
+    if (a.root === b.root)
+        throw new Error("not equivocation: same root — the views agree");
+    if (!valid(a) || !valid(b))
+        throw new Error("not equivocation: an STH signature is invalid (a forgery proves nothing)");
+    const [x, y] = a.root < b.root ? [a, b] : [b, a];
+    return { v: 1, type: "federation.equivocation", log_id: a.log_id, size: a.size, sths: [x, y] };
+}
+/** Re-checks a proof from scratch: both signatures, same log, same size, different roots. */
+export function verifyEquivocationProof(proof) {
+    const p = (proof ?? {});
+    const sths = p.sths;
+    if (p.v !== 1 ||
+        p.type !== "federation.equivocation" ||
+        !Array.isArray(sths) ||
+        sths.length !== 2)
+        return false;
+    const [a, b] = sths;
+    if (!a || !b || typeof a !== "object" || typeof b !== "object")
+        return false;
+    return (a.log_id === p.log_id &&
+        b.log_id === p.log_id &&
+        a.size === p.size &&
+        b.size === p.size &&
+        a.root !== b.root &&
+        valid(a) &&
+        valid(b));
+}
+/**
+ * Zanii's gossip comparison over views already fetched: views of other logs and bad signatures
+ * are set aside, and two valid views at one size with different roots are an equivocation proof.
+ */
+export function compareViews(logId, views) {
+    const reasons = [];
+    const bySize = new Map();
+    let usable = 0;
+    for (const v of views) {
+        const sth = v.sth;
+        if (sth === undefined || sth === null) {
+            reasons.push(`${v.source}: unreachable (${v.error})`);
+            continue;
+        }
+        if (typeof sth !== "object") {
+            reasons.push(`${v.source}: not a signed tree head`);
+            continue;
+        }
+        const s = sth;
+        if (s.log_id !== logId) {
+            reasons.push(`${v.source}: serves a different log (${String(s.log_id)})`);
+            continue;
+        }
+        if (!valid(s)) {
+            reasons.push(`${v.source}: the signature doesn't verify`);
+            continue;
+        }
+        usable++;
+        const seen = bySize.get(s.size);
+        if (seen && seen.sth.root !== s.root) {
+            const equivocation = buildEquivocationProof(seen.sth, s);
+            reasons.push(`split view: ${seen.source} and ${v.source} show different roots at size ${s.size}`);
+            return { ok: false, reasons, equivocation };
+        }
+        if (!seen)
+            bySize.set(s.size, { source: v.source, sth: s });
+    }
+    if (usable === 0)
+        reasons.push("no usable views");
+    return { ok: usable > 0, reasons };
+}

package/dist/finance/index.d.ts

@@ -0,0 +1,126 @@
+type Obj = Record<string, unknown>;
+/** Minor-unit precision: Zanii's table, plus the Gulf's currencies. */
+export declare const CURRENCIES: Readonly<Record<string, number>>;
+/** Zanii's exact parse: a decimal string to minor units (a string), never a float. */
+export declare function parseMoney(amount: string | number, currency: string): {
+    currency: string;
+    minor: string;
+    display: string;
+};
+export declare const formatMoney: (minor: string | number | bigint, currency: string) => string;
+/** Zanii's payment receipt payload. No settlement reference, no payment. */
+export declare function buildPayment(input: {
+    rail: string;
+    reference: string;
+    amount: string | number;
+    currency: string;
+    from?: string;
+    to?: string;
+    memo?: string;
+    extra?: Obj;
+}): {
+    target: string;
+    rail: string;
+    reference: string;
+    money: {
+        currency: string;
+        minor: string;
+        display: string;
+    };
+    from: string | null;
+    to: string | null;
+    memo: string | null;
+    extra: Obj | null;
+};
+/** Zanii's KYA screen, offline: the DID or its owner on a deny list is a hit. */
+export declare function screenCounterparty(did: string, opts?: {
+    denyList?: readonly string[];
+    owner?: string;
+}): {
+    did: string;
+    owner: string | null;
+    ok: boolean;
+    hits: {
+        source: string;
+        detail: string;
+    }[];
+    history: null;
+};
+/** Zanii's kya.screening payload for a screening result. */
+export declare function screeningPayload(result: ReturnType<typeof screenCounterparty>, ts: string, screenedBy?: string | null): {
+    _zr_kind: string;
+    v: number;
+    did: string;
+    owner: string | null;
+    ok: boolean;
+    hits: {
+        source: string;
+        detail: string;
+    }[];
+    sources: string[];
+    screened_by: string | null;
+    ts: string;
+};
+export declare const FTA_WALL_ID = "fta-prepares-never-files";
+/** Zanii's FTA payloads: a filing prepared (never filed), and its hand-off to a Tax Agent. */
+export declare function ftaPayload(input: {
+    action: "prepared" | "handoff";
+    filingType: string;
+    period: string;
+    by: string;
+    toTaxAgent?: string;
+    filingRef?: string;
+    manifestHash?: string;
+}): Obj;
+/** Zanii's kyb.attestation: an owner DID signs which domain and legal entity it is. */
+export declare function buildOwnerAttestation(input: {
+    did: string;
+    domain: string;
+    entity: {
+        name: string;
+        jurisdiction?: string;
+        registration?: string;
+    };
+    ts: string;
+    ownerPrivateKey: Uint8Array;
+}): {
+    v: number;
+    type: string;
+    did: string;
+    domain: string;
+    entity: {
+        name: string;
+        jurisdiction?: string;
+        registration?: string;
+    };
+    ts: string;
+    sig: string;
+};
+export declare function verifyOwnerAttestation(a: unknown): boolean;
+/** Zanii's two-way check: the owner signed it, and the domain's own doc lists that owner. */
+export declare function verifyOwnerBinding(attestation: unknown, doc: unknown): {
+    ok: boolean;
+    reasons: string[];
+    entity: Obj | null;
+};
+export declare function financeFindings(lines: readonly string[], bodies: (hash: string) => Uint8Array | undefined, closing?: boolean): {
+    code: string;
+    source: string;
+    severity: "warning" | "advisory";
+    ref: Record<string, string | number>;
+    detail: string;
+}[];
+/** spec/finance.md §2: the session's payments, and exact totals per currency (minor units). */
+export declare function paymentsOf(lines: readonly string[], bodies: (hash: string) => Uint8Array | undefined): {
+    payments: {
+        seq: number;
+        rail: unknown;
+        reference: unknown;
+        money: Obj;
+        to: unknown;
+    }[];
+    totals: {
+        [k: string]: string;
+    };
+};
+export {};

package/dist/finance/index.js

@@ -0,0 +1,320 @@
+// Finance (spec/finance.md): exact money and payments (@zanii/payments), counterparty screening
+// (@zanii/kya), tax filings prepared, never filed (@zanii/fta), the owner behind a counterparty
+// (@zanii/kyb), and the findings over them. Pure; mirrors sdks/python/src/zanii_blackbox/finance.py;
+// pinned by spec/vectors/finance.json.
+import { canonicalBytes, publicKeyFromDid } from "@zanii/core";
+import { ed25519Sign, ed25519Verify } from "../transparency/index.js";
+/** Minor-unit precision: Zanii's table, plus the Gulf's currencies. */
+export const CURRENCIES = {
+    USD: 2,
+    EUR: 2,
+    GBP: 2,
+    CHF: 2,
+    CAD: 2,
+    AUD: 2,
+    CNY: 2,
+    INR: 2,
+    JPY: 0,
+    KRW: 0,
+    USDC: 6,
+    USDT: 6,
+    BTC: 8,
+    ZAN: 9,
+    ETH: 18,
+    AED: 2,
+    SAR: 2,
+    QAR: 2,
+    KWD: 3,
+    BHD: 3,
+    OMR: 3,
+};
+function decimalsOf(currency) {
+    const d = CURRENCIES[currency.toUpperCase()];
+    if (d === undefined)
+        throw new Error(`unknown currency '${currency}'`);
+    return d;
+}
+function formatMinorUnits(minor, decimals) {
+    const neg = minor < 0n;
+    const m = neg ? -minor : minor;
+    const base = 10n ** BigInt(decimals);
+    const whole = m / base;
+    if (decimals === 0)
+        return `${neg ? "-" : ""}${whole}`;
+    return `${neg ? "-" : ""}${whole}.${(m % base).toString().padStart(decimals, "0")}`;
+}
+/** Zanii's exact parse: a decimal string to minor units (a string), never a float. */
+export function parseMoney(amount, currency) {
+    const decimals = decimalsOf(currency);
+    const s = String(amount).trim();
+    if (!/^\d+(\.\d+)?$/.test(s))
+        throw new Error(`invalid amount '${s}' (expected a non-negative decimal)`);
+    const [whole = "0", frac = ""] = s.split(".");
+    if (frac.length > decimals)
+        throw new Error(`amount '${s}' has more precision than ${currency} allows (${decimals} dp)`);
+    const minor = BigInt(whole) * 10n ** BigInt(decimals) + BigInt(frac.padEnd(decimals, "0") || "0");
+    if (minor <= 0n)
+        throw new Error("amount must be > 0");
+    const cur = currency.toUpperCase();
+    return {
+        currency: cur,
+        minor: minor.toString(),
+        display: `${formatMinorUnits(minor, decimals)} ${cur}`,
+    };
+}
+export const formatMoney = (minor, currency) => formatMinorUnits(BigInt(minor), decimalsOf(currency));
+/** Zanii's payment receipt payload. No settlement reference, no payment. */
+export function buildPayment(input) {
+    if (!input.rail)
+        throw new Error("rail is required");
+    if (!input.reference)
+        throw new Error("reference is required (a payment with no settlement reference is unprovable)");
+    return {
+        target: `pay.${input.rail.toLowerCase()}`,
+        rail: input.rail,
+        reference: input.reference,
+        money: parseMoney(input.amount, input.currency),
+        from: input.from ?? null,
+        to: input.to ?? null,
+        memo: input.memo ?? null,
+        extra: input.extra ?? null,
+    };
+}
+/** Zanii's KYA screen, offline: the DID or its owner on a deny list is a hit. */
+export function screenCounterparty(did, opts = {}) {
+    if (!did)
+        throw new Error("did is required");
+    const deny = new Set(opts.denyList ?? []);
+    const hits = [];
+    if (deny.has(did))
+        hits.push({ source: "deny-list", detail: did });
+    if (opts.owner && deny.has(opts.owner))
+        hits.push({ source: "deny-list", detail: opts.owner });
+    return { did, owner: opts.owner ?? null, ok: hits.length === 0, hits, history: null };
+}
+/** Zanii's kya.screening payload for a screening result. */
+export function screeningPayload(result, ts, screenedBy = null) {
+    const sources = [...new Set(result.hits.map((h) => h.source))].sort();
+    return {
+        _zr_kind: "kya",
+        v: 1,
+        did: result.did,
+        owner: result.owner,
+        ok: result.ok,
+        hits: result.hits,
+        sources,
+        screened_by: screenedBy,
+        ts,
+    };
+}
+export const FTA_WALL_ID = "fta-prepares-never-files";
+/** Zanii's FTA payloads: a filing prepared (never filed), and its hand-off to a Tax Agent. */
+export function ftaPayload(input) {
+    if (!input.filingType)
+        throw new Error("filing_type is required");
+    if (!input.period)
+        throw new Error("period is required");
+    if (input.action === "prepared")
+        return {
+            _zr_kind: "fta",
+            v: 1,
+            action: "prepared",
+            filing_type: input.filingType,
+            period: input.period,
+            prepared_by: input.by,
+            filing_ref: input.filingRef ?? null,
+            manifest_hash: input.manifestHash ?? null,
+            wall: FTA_WALL_ID,
+        };
+    if (!input.toTaxAgent)
+        throw new Error("to_tax_agent (the licensed Tax Agent) is required");
+    return {
+        _zr_kind: "fta",
+        v: 1,
+        action: "handoff",
+        filing_type: input.filingType,
+        period: input.period,
+        from_agent: input.by,
+        to_tax_agent: input.toTaxAgent,
+        filing_ref: input.filingRef ?? null,
+        wall: FTA_WALL_ID,
+    };
+}
+// ---------------------------------------------------------------- KYB: the owner behind a party
+/** Zanii's kyb.attestation: an owner DID signs which domain and legal entity it is. */
+export function buildOwnerAttestation(input) {
+    if (!input.did)
+        throw new Error("did is required");
+    if (!input.domain)
+        throw new Error("domain is required");
+    if (!input.entity?.name)
+        throw new Error("entity.name is required");
+    if (Number.isNaN(Date.parse(input.ts)))
+        throw new Error("ts must be an ISO timestamp");
+    const unsigned = {
+        v: 1,
+        type: "kyb.attestation",
+        did: input.did,
+        domain: input.domain.toLowerCase(),
+        entity: input.entity,
+        ts: input.ts,
+    };
+    const sig = Buffer.from(ed25519Sign(input.ownerPrivateKey, canonicalBytes(unsigned))).toString("hex");
+    return { ...unsigned, sig: `ed25519:${sig}` };
+}
+export function verifyOwnerAttestation(a) {
+    const p = (a ?? {});
+    if (p.v !== 1 || p.type !== "kyb.attestation" || !p.did || !p.domain)
+        return false;
+    const entity = p.entity;
+    if (!entity || typeof entity !== "object" || !entity.name)
+        return false;
+    if (typeof p.ts !== "string" || Number.isNaN(Date.parse(p.ts)))
+        return false;
+    const pub = publicKeyFromDid(String(p.did));
+    const m = typeof p.sig === "string" ? /^ed25519:([0-9a-f]{128})$/.exec(p.sig) : null;
+    if (!pub || !m)
+        return false;
+    const { sig: _sig, ...unsigned } = p;
+    return ed25519Verify(pub, canonicalBytes(unsigned), Buffer.from(m[1], "hex"));
+}
+/** Zanii's two-way check: the owner signed it, and the domain's own doc lists that owner. */
+export function verifyOwnerBinding(attestation, doc) {
+    const a = (attestation ?? {});
+    if (!verifyOwnerAttestation(attestation))
+        return { ok: false, reasons: ["attestation is not validly signed by its DID"], entity: null };
+    const d = (doc ?? {});
+    if (d.v !== 1 ||
+        typeof d.domain !== "string" ||
+        typeof d.entity !== "object" ||
+        d.entity === null ||
+        !d.entity.name ||
+        !Array.isArray(d.owner_dids))
+        return {
+            ok: false,
+            reasons: [
+                `${a.domain} publishes no valid owner doc — the domain side of the binding is missing`,
+            ],
+            entity: null,
+        };
+    const reasons = [];
+    if (d.domain.toLowerCase() !== a.domain.toLowerCase())
+        reasons.push(`attestation names ${a.domain} but the doc is for ${d.domain}`);
+    if (!d.owner_dids.includes(a.did))
+        reasons.push(`the domain does not list ${a.did} — anyone can sign a claim; only the domain's list makes it mutual`);
+    if (d.entity.name !== a.entity.name)
+        reasons.push(`entity name mismatch: domain says '${String(d.entity.name)}', owner claims '${String(a.entity.name)}'`);
+    for (const field of ["jurisdiction", "registration"]) {
+        const x = a.entity[field];
+        const y = d.entity[field];
+        if (x !== undefined && y !== undefined && x !== y)
+            reasons.push(`entity ${field} mismatch: domain says '${String(y)}', owner claims '${String(x)}'`);
+    }
+    return { ok: reasons.length === 0, reasons, entity: reasons.length === 0 ? d.entity : null };
+}
+const decoder = new TextDecoder();
+export function financeFindings(lines, bodies, closing = false) {
+    let closed = closing;
+    const out = [];
+    const screened = new Map();
+    const prepared = [];
+    const handedOff = new Set();
+    for (const l of lines) {
+        const e = JSON.parse(l);
+        if (e.kind === "session.close")
+            closed = true;
+        if (e.kind !== "sdk.event")
+            continue;
+        const type = e.meta.type;
+        if (type !== "payment" &&
+            type !== "kya.screening" &&
+            type !== "fta.prepared" &&
+            type !== "fta.handoff")
+            continue;
+        const body = bodies(e.body_hash);
+        let data = {};
+        try {
+            data = body ? JSON.parse(decoder.decode(body)) : {};
+        }
+        catch { }
+        if (type === "kya.screening" && typeof data.did === "string")
+            screened.set(data.did, { ok: data.ok === true, seq: e.seq });
+        else if (type === "payment" && typeof data.to === "string" && data.to) {
+            const s = screened.get(data.to);
+            if (!s)
+                out.push({
+                    code: "UNSCREENED_COUNTERPARTY",
+                    source: "detectors",
+                    severity: "warning",
+                    ref: { seq: e.seq, to: data.to },
+                    detail: "A payment to a counterparty this session never screened first.",
+                });
+            else if (!s.ok)
+                out.push({
+                    code: "SCREENING_HIT_PAID",
+                    source: "detectors",
+                    severity: "warning",
+                    ref: { seq: e.seq, to: data.to, screening_seq: s.seq },
+                    detail: "A payment to a counterparty whose screening had hits.",
+                });
+        }
+        else if (type === "fta.prepared" || type === "fta.handoff") {
+            const key = `${String(data.filing_type)}\u0000${String(data.period)}`;
+            if (type === "fta.handoff")
+                handedOff.add(key);
+            else
+                prepared.push({
+                    seq: e.seq,
+                    key,
+                    filing_type: String(data.filing_type),
+                    period: String(data.period),
+                });
+        }
+    }
+    if (closed)
+        for (const p of prepared)
+            if (!handedOff.has(p.key))
+                out.push({
+                    code: "FTA_NO_HANDOFF",
+                    source: "detectors",
+                    severity: "advisory",
+                    ref: { seq: p.seq, filing_type: p.filing_type, period: p.period },
+                    detail: "A tax filing was prepared and never handed to a licensed Tax Agent.",
+                });
+    return out;
+}
+/** spec/finance.md §2: the session's payments, and exact totals per currency (minor units). */
+export function paymentsOf(lines, bodies) {
+    const payments = [];
+    const totals = new Map();
+    for (const l of lines) {
+        const e = JSON.parse(l);
+        if (e.kind !== "sdk.event" || e.meta.type !== "payment")
+            continue;
+        const body = bodies(e.body_hash);
+        let p;
+        try {
+            p = body ? JSON.parse(decoder.decode(body)) : {};
+        }
+        catch {
+            continue;
+        }
+        const m = p.money;
+        if (!m || typeof m !== "object")
+            continue;
+        payments.push({
+            seq: e.seq,
+            rail: p.rail ?? null,
+            reference: p.reference ?? null,
+            money: m,
+            to: p.to ?? null,
+        });
+        const cur = String(m.currency);
+        totals.set(cur, (totals.get(cur) ?? 0n) + BigInt(String(m.minor)));
+    }
+    const sorted = [...totals.keys()].sort();
+    return {
+        payments,
+        totals: Object.fromEntries(sorted.map((k) => [k, String(totals.get(k))])),
+    };
+}

package/dist/fleet/index.js

@@ -6,6 +6,7 @@ import { toolCallsOf } from "../analysis/detectors.js";
 import { FAULTS } from "../analysis/faults.js";
 import { eventsOf } from "../analysis/index.js";
 import { landing } from "../analysis/landing.js";
+import { authorityTimeline } from "../authority/index.js";
 import { formatAed, sessionCost, toAedFils } from "../cost/index.js";
 import { callsOf } from "../reconcile/record.js";
 import { canonical } from "../reconcile/shared.js";
@@ -60,10 +61,18 @@ export function sessionSummary(lines, bodies, prices) {
     const claims = { satisfied: 0, failed: 0, unverified: 0 };
     for (const c of landing(eventsOf(lines, bodies), lines, bodies).claims)
         claims[c.verdict]++;
+    const inControl = authorityTimeline(lines).at(-1)?.mode ?? "agent";
     return {
         session_id: first.session_id,
         label: typeof first.meta.label === "string" ? first.meta.label : null,
         tenant: typeof first.meta.tenant === "string" ? first.meta.tenant : null,
+        // spec/api.md: only when the session has one, so older summaries read the same
+        ...(typeof first.meta.environment === "string" ? { environment: first.meta.environment } : {}),
+        // spec/fleet.md §2: the budget, when there is one; who flies, when it isn't the agent
+        ...(typeof first.meta.budget_micro_usd === "number"
+            ? { budget_micro_usd: first.meta.budget_micro_usd }
+            : {}),
+        ...(inControl !== "agent" ? { in_control: inControl } : {}),
         objective: typeof plan?.objective === "string" ? plan.objective : null,
         started_at: first.ts,
         last_event_at: last.ts,

package/dist/gov/index.d.ts

@@ -0,0 +1,108 @@
+type Text = {
+    en: string;
+    ar: string;
+};
+type Obj = Record<string, unknown>;
+export declare const GOV_DECISION_KINDS: readonly ["benefit.grant", "benefit.deny", "visa.decide", "fine.issue", "licence.decide"];
+/** Zanii's pseudonymous, authority-scoped tag for a person's did:key. */
+export declare function subjectTag(subjectDid: string, authority: string): string;
+/** Zanii's subject claim: "this is my slice", signed with the person's own key. */
+export declare function signSubjectClaim(input: {
+    platform: string;
+    subjectDid: string;
+    ts: string;
+    subjectPrivateKey: Uint8Array;
+}): {
+    v: number;
+    type: string;
+    platform: string;
+    subject: string;
+    tag: string;
+    ts: string;
+    sig: string;
+};
+/** The subject signed it, and the tag derives from that subject at that platform. */
+export declare function verifySubjectClaim(claim: unknown): boolean;
+/** Zanii's decision payload, v1, for a government decision. No rulebook, no decision. */
+export declare function decisionPayload(input: {
+    kind: string;
+    manifestHash: string;
+    outcome: Obj;
+    ts: string;
+    factors?: Obj;
+    appealBy?: string;
+    nonce?: string;
+}): {
+    payload: Obj;
+    nonce: string;
+};
+/** The disclosed factors and nonce match the commitment made at decision time. */
+export declare const verifyFactors: (factors: unknown, nonce: string, commitment: string) => boolean;
+/** Zanii's structural check of a decision payload. */
+export declare function verifyDecision(payload: unknown): {
+    ok: boolean;
+    reasons: string[];
+};
+/** Zanii's rulebook windows over time; interleaving is the red flag. */
+export declare function ruleConsistency(payloads: readonly unknown[]): {
+    rulebooks: {
+        manifest_hash: string;
+        count: number;
+        first_ts: string;
+        last_ts: string;
+    }[];
+    consistent: boolean;
+    reasons: string[];
+};
+export interface AppealItem {
+    session_id: string;
+    seq: number;
+    line: string;
+    event_hash: string;
+    anchored: boolean;
+    decision: unknown;
+}
+/** spec/gov.md §3: the citizen's appeal pack over the decisions recorded about their tag. */
+export declare function appealPack(items: readonly AppealItem[], opts: {
+    tag: string;
+    authority: string;
+    generated_at: string;
+}): {
+    v: 1;
+    legal_basis: Text;
+    subject_tag: string;
+    authority: string;
+    decisions: number;
+    rules: {
+        rulebooks: {
+            manifest_hash: string;
+            count: number;
+            first_ts: string;
+            last_ts: string;
+        }[];
+        consistent: boolean;
+        reasons: string[];
+    };
+    unruled: number;
+    period: {
+        first: string | null;
+        last: string | null;
+    };
+    items: {
+        session_id: string;
+        seq: number;
+        line: string;
+        event_hash: string;
+        anchored: boolean;
+    }[];
+    steps: {
+        en: string;
+        ar: string;
+        n: number;
+    }[];
+    generated_at: string;
+};
+export type AppealPack = ReturnType<typeof appealPack>;
+/** The reading copy for an administrative judge: `en`, `ar` or `both` (headers always bilingual). */
+export declare function renderAppealPack(pack: AppealPack, lang?: "en" | "ar" | "both"): string;
+export {};