@zanii/blackbox 0.2.0 → 0.4.0

package/dist/gov/index.js

@@ -0,0 +1,225 @@
+// Government decisions about people, and the citizen's appeal pack (spec/gov.md), on Zanii's
+// subject tags, subject claims and decision payloads (@zanii/subject, @zanii/decisions, @zanii/gov).
+// Pure; mirrors sdks/python/src/zanii_blackbox/gov.py; pinned by spec/vectors/gov.json.
+import { createHash, randomBytes } from "node:crypto";
+import { canonicalBytes, jcsHash, publicKeyFromDid } from "@zanii/core";
+import { canonical } from "../reconcile/shared.js";
+import { ed25519Sign, ed25519Verify } from "../transparency/index.js";
+export const GOV_DECISION_KINDS = [
+    "benefit.grant",
+    "benefit.deny",
+    "visa.decide",
+    "fine.issue",
+    "licence.decide",
+];
+const KIND = /^[a-z][a-z0-9.]{0,63}$/;
+const validTs = (ts) => typeof ts === "string" && !Number.isNaN(Date.parse(ts));
+/** Zanii's pseudonymous, authority-scoped tag for a person's did:key. */
+export function subjectTag(subjectDid, authority) {
+    if (!subjectDid || !authority)
+        throw new Error("subject_did and platform_id are required");
+    return jcsHash({ v: 1, type: "subject_tag", platform: authority, subject: subjectDid });
+}
+/** Zanii's subject claim: "this is my slice", signed with the person's own key. */
+export function signSubjectClaim(input) {
+    if (!validTs(input.ts))
+        throw new Error("ts must be an ISO timestamp");
+    const unsigned = {
+        v: 1,
+        type: "subject_claim",
+        platform: input.platform,
+        subject: input.subjectDid,
+        tag: subjectTag(input.subjectDid, input.platform),
+        ts: input.ts,
+    };
+    const sig = Buffer.from(ed25519Sign(input.subjectPrivateKey, canonicalBytes(unsigned))).toString("hex");
+    return { ...unsigned, sig: `ed25519:${sig}` };
+}
+/** The subject signed it, and the tag derives from that subject at that platform. */
+export function verifySubjectClaim(claim) {
+    const c = (claim ?? {});
+    if (c.v !== 1 || c.type !== "subject_claim")
+        return false;
+    try {
+        if (subjectTag(String(c.subject ?? ""), String(c.platform ?? "")) !== c.tag)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    const pub = publicKeyFromDid(String(c.subject));
+    const m = typeof c.sig === "string" ? /^ed25519:([0-9a-f]{128})$/.exec(c.sig) : null;
+    if (!pub || !m)
+        return false;
+    const { sig: _sig, ...unsigned } = c;
+    return ed25519Verify(pub, canonicalBytes(unsigned), Buffer.from(m[1], "hex"));
+}
+const commit = (factors, nonce) => `sha256:${createHash("sha256")
+    .update(Buffer.from(nonce, "hex"))
+    .update(canonical(factors))
+    .digest("hex")}`;
+/** Zanii's decision payload, v1, for a government decision. No rulebook, no decision. */
+export function decisionPayload(input) {
+    if (!KIND.test(input.kind))
+        throw new Error("kind must be lowercase, 1-64 characters, a-z 0-9 .");
+    if (!input.manifestHash)
+        throw new Error("manifest_hash is required: a state decision with no governing rulebook on record is not auditable, and must not be issued");
+    if (!validTs(input.ts))
+        throw new Error("ts must be an ISO timestamp");
+    if (input.appealBy !== undefined && !validTs(input.appealBy))
+        throw new Error("appeal_by must be an ISO date");
+    const nonce = input.factors !== undefined ? (input.nonce ?? randomBytes(16).toString("hex")) : "";
+    const payload = {
+        _zr_kind: "decision",
+        v: 1,
+        kind: input.kind,
+        manifest_hash: input.manifestHash,
+        outcome: input.outcome,
+        ts: input.ts,
+        ...(input.factors !== undefined ? { factors_commitment: commit(input.factors, nonce) } : {}),
+        ...(input.appealBy !== undefined ? { appeal_by: input.appealBy } : {}),
+        _zr_domain: "gov",
+    };
+    return { payload, nonce };
+}
+/** The disclosed factors and nonce match the commitment made at decision time. */
+export const verifyFactors = (factors, nonce, commitment) => /^[0-9a-f]{32}$/.test(nonce) && commit(factors, nonce) === commitment;
+/** Zanii's structural check of a decision payload. */
+export function verifyDecision(payload) {
+    const p = (payload ?? {});
+    const reasons = [];
+    if (p._zr_kind !== "decision" || p.v !== 1)
+        reasons.push("not a decision receipt (v1)");
+    if (!p.kind)
+        reasons.push("missing kind");
+    if (typeof p.manifest_hash !== "string" || !p.manifest_hash)
+        reasons.push("missing manifest_hash (no governing rulebook)");
+    if (!validTs(p.ts))
+        reasons.push("missing/invalid ts");
+    return { ok: reasons.length === 0, reasons };
+}
+/** Zanii's rulebook windows over time; interleaving is the red flag. */
+export function ruleConsistency(payloads) {
+    const reasons = [];
+    const windows = new Map();
+    const sorted = [...payloads].sort((a, b) => {
+        const x = String(a?.ts);
+        const y = String(b?.ts);
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+    for (const p of sorted) {
+        const check = verifyDecision(p);
+        if (!check.ok) {
+            reasons.push(`invalid decision: ${check.reasons.join("; ")}`);
+            continue;
+        }
+        const h = String(p.manifest_hash);
+        const ts = String(p.ts);
+        const w = windows.get(h);
+        if (w) {
+            w.count++;
+            w.last_ts = ts;
+        }
+        else
+            windows.set(h, { manifest_hash: h, count: 1, first_ts: ts, last_ts: ts });
+    }
+    const rulebooks = [...windows.values()].sort((a, b) => a.first_ts < b.first_ts ? -1 : a.first_ts > b.first_ts ? 1 : 0);
+    for (let i = 1; i < rulebooks.length; i++) {
+        const prev = rulebooks[i - 1];
+        const cur = rulebooks[i];
+        if (cur.first_ts < prev.last_ts)
+            reasons.push(`rulebooks ${prev.manifest_hash} and ${cur.manifest_hash} interleave — rules differed between people at the same time`);
+    }
+    return { rulebooks, consistent: reasons.length === 0, reasons };
+}
+const LEGAL_BASIS = {
+    en: "This pack is a self-contained, independently verifiable record of the automated decisions taken about the holder by the issuing authority. Each decision names the rulebook that governed it, and the pack is signed by the gateway that recorded it. A court or appointed expert can verify every element offline, without the cooperation of the authority that produced it.",
+    ar: "هذه الحزمة سجلّ قائم بذاته وقابل للتحقّق المستقل للقرارات الآلية التي اتُّخذت بشأن حاملها من قبل الجهة المُصدِرة. يذكر كل قرار القواعد التي حكمته، والحزمة موقّعة من البوابة التي سجّلته. ويمكن للمحكمة أو الخبير المعيّن التحقّق من كل عنصر دون اتصال ودون تعاون الجهة التي أصدرته.",
+};
+const STEPS = [
+    {
+        en: "Verify the pack's signature against the gateway's published log key (did:key).",
+        ar: "تحقّق من توقيع الحزمة مقابل مفتاح السجل المنشور للبوابة (did:key).",
+    },
+    {
+        en: "Verify each decision line hashes (SHA-256) to the event hash given for it: the line is exactly what was recorded.",
+        ar: "تحقّق من أن تجزئة كل سطر قرار (SHA-256) تساوي تجزئة الحدث المذكورة له: السطر هو ما سُجّل بالضبط.",
+    },
+    {
+        en: "Confirm every decision names the rulebook that governed it (manifest_hash): a decision without one is not evidence of a lawful process.",
+        ar: "تأكّد من أنّ كل قرار يذكر القواعد الحاكمة له (بصمة القواعد): فالقرار الخالي منها ليس دليلاً على إجراء سليم.",
+    },
+    {
+        en: "Check rule-consistency: the same rulebook decided everyone in the period, and any change of rules is visible and dated.",
+        ar: "تحقّق من اتساق القواعد: أنّ القواعد نفسها طُبِّقت على الجميع في المدة، وأنّ أي تغيير فيها ظاهر ومؤرَّخ.",
+    },
+    {
+        en: "With the session records the authority discloses, verify each line is in its session's hash chain and under its anchors: it was not added afterwards.",
+        ar: "مع سجلات الجلسات التي تفصح عنها الجهة، تحقّق من أن كل سطر ضمن سلسلة تجزئة جلسته وتحت تثبيتاتها: لم يُضَف لاحقًا.",
+    },
+    {
+        en: "On dispute, the authority discloses the committed decision factors and their nonce; verify they match the commitment made at decision time (no reasoning added afterwards).",
+        ar: "عند النزاع، تفصح الجهة عن عوامل القرار المُلتزَم بها ومعامل الملح؛ تحقّق من مطابقتها للالتزام وقت اتخاذ القرار (لا تبرير لاحق).",
+    },
+];
+/** spec/gov.md §3: the citizen's appeal pack over the decisions recorded about their tag. */
+export function appealPack(items, opts) {
+    const payloads = items.map((i) => i.decision);
+    const times = payloads
+        .map((p) => p?.ts)
+        .filter((t) => typeof t === "string")
+        .sort();
+    return {
+        v: 1,
+        legal_basis: LEGAL_BASIS,
+        subject_tag: opts.tag,
+        authority: opts.authority,
+        decisions: items.length,
+        rules: ruleConsistency(payloads),
+        unruled: payloads.filter((p) => !verifyDecision(p).ok).length,
+        period: { first: times[0] ?? null, last: times.at(-1) ?? null },
+        items: items.map(({ session_id, seq, line, event_hash, anchored }) => ({
+            session_id,
+            seq,
+            line,
+            event_hash,
+            anchored,
+        })),
+        steps: STEPS.map((s, i) => ({ n: i + 1, ...s })),
+        generated_at: opts.generated_at,
+    };
+}
+/** The reading copy for an administrative judge: `en`, `ar` or `both` (headers always bilingual). */
+export function renderAppealPack(pack, lang = "both") {
+    const show = (b) => (lang === "en" ? b.en : lang === "ar" ? b.ar : `${b.en}\n\n> ${b.ar}`);
+    const steps = pack.steps.map((s) => `${s.n}. ${show(s)}`).join("\n");
+    const rulebooks = pack.rules.rulebooks
+        .map((w) => `- \`${w.manifest_hash}\` — ${w.count} decision(s), ${w.first_ts} → ${w.last_ts}`)
+        .join("\n") || "- (none)";
+    const flags = [];
+    if (!pack.rules.consistent)
+        flags.push("⚠️ RULES INTERLEAVED — different rulebooks decided people at the same time");
+    if (pack.unruled > 0)
+        flags.push(`❌ ${pack.unruled} decision(s) carry NO governing rulebook`);
+    const findings = flags.length
+        ? `## Findings / النتائج\n\n${flags.map((f) => `- ${f}`).join("\n")}\n\n`
+        : "";
+    const p = pack.period;
+    return ("# Appeal Pack / حزمة الطعن\n\n" +
+        `- **Subject (pseudonymous) / الشخص المعني (مستعار):** \`${pack.subject_tag}\`\n` +
+        `- **Authority / الجهة:** ${pack.authority || "—"}\n` +
+        `- **Decisions / القرارات:** ${pack.decisions}\n` +
+        `- **Period / المدة:** ${p.first ?? "—"} → ${p.last ?? "—"}\n\n` +
+        findings +
+        `## Legal basis / الأساس القانوني\n\n${show(pack.legal_basis)}\n\n` +
+        `## Rulebooks applied / القواعد المطبَّقة\n\n${rulebooks}\n\n` +
+        `## Verification steps / خطوات التحقّق\n\n${steps}\n\n` +
+        "## What this does and does not prove / ما تثبته هذه الحزمة وما لا تثبته\n\n" +
+        "It proves the **process**: the same rules decided everyone, the record is complete and " +
+        "unaltered, and the inputs were committed at decision time. It does **not** prove the " +
+        "decision was *just* — a rule applied consistently may still be unlawful. That judgment " +
+        "is the court's.\n\n" +
+        "> تُثبت هذه الحزمة **سلامة الإجراء**: أنّ القواعد نفسها طُبِّقت على الجميع، وأنّ السجل كامل " +
+        "وغير مُعدَّل، وأنّ المعطيات التُزم بها وقت القرار. ولا تُثبت **عدالة** القرار — فالقاعدة " +
+        "المطبَّقة باتساق قد تظل مخالفة للقانون، وهذا تقدير المحكمة.\n");
+}

package/dist/health/index.d.ts

@@ -0,0 +1,120 @@
+type Obj = Record<string, unknown>;
+/** The patient's seed, for the patient's own app. It never leaves the patient. */
+export declare function episodeSeed(secretHex?: string): {
+    v: 1;
+    secret: string;
+};
+/** Zanii's tag for encounter n, derived by the patient; two tags can't be linked without the seed. */
+export declare function episodeTag(seed: {
+    secret: string;
+}, n: number): string;
+/** The tag, or an error: the patient supplies the tag, never the seed. */
+export declare function checkEpisodeTag(tag: unknown): string;
+/** A disclosed value and nonce match the commitment made at the time. */
+export declare const verifyCommitment: (value: unknown, nonce: string, commitment: string) => boolean;
+/** Zanii's health.access payload: who accessed the record, and why. */
+export declare function accessPayload(input: {
+    actor: string;
+    purpose: string;
+    ts: string;
+    consentRef?: string;
+    details?: Obj;
+    nonce?: string;
+}): {
+    payload: Obj;
+    nonce: string;
+};
+/** What the clinician signs: jcsHash of the recommendation payload. */
+export declare const recommendationHash: (payload: Obj) => string;
+/** Zanii's health.recommendation payload. No protocol, no recommendation; a deviation is recorded, never refused. */
+export declare function recommendationPayload(input: {
+    modelId: string;
+    manifestHash: string;
+    outcome: Obj;
+    ts: string;
+    runtimeHash?: string;
+    deviation?: Obj;
+    nonce?: string;
+}): {
+    payload: Obj;
+    nonce: string;
+    hash: string;
+};
+/** Zanii's health.confirmation payload, signed on the clinician's own device. */
+export declare function clinicianConfirmation(input: {
+    episodeTag: string;
+    clinicianDid: string;
+    recommendationHash: string;
+    confirmedAt: string;
+    clinicianPrivateKey: Uint8Array;
+}): Obj;
+/** Zanii's health.break_glass payload: emergency access, signed personally. Kept open on purpose, and loud. */
+export declare function breakGlass(input: {
+    episodeTag: string;
+    clinicianDid: string;
+    reason: string;
+    ts: string;
+    clinicianPrivateKey: Uint8Array;
+}): Obj;
+/** A confirmation or break-glass is signed by the clinician it names, over the action it names. */
+export declare function verifyHealthSignature(payload: unknown, tag: string): boolean;
+/** Zanii's protocol trail. No verdict on uniformity (individualised care is correct medicine). */
+export declare function protocolTrail(payloads: readonly unknown[]): {
+    protocols: {
+        manifest_hash: unknown;
+        count: number;
+        first_ts: unknown;
+        last_ts: unknown;
+    }[];
+    deviations: number;
+    unprotocolled: number;
+};
+export interface EpisodeItem {
+    session_id: string;
+    seq: number;
+    line: string;
+    event_hash: string;
+    anchored: boolean;
+    payload: Obj;
+    tag: string;
+}
+/** spec/health.md §4: the patient's episodes; `reviewed` holds "<session_id>:<seq>" of reviewed break-glass. */
+export declare function episodesPack(items: readonly EpisodeItem[], o: {
+    tags: readonly string[];
+    reviewed: readonly string[];
+    generated_at: string;
+}): {
+    v: number;
+    episodes: {
+        tag: string;
+        items: {
+            session_id: string;
+            seq: number;
+            line: string;
+            event_hash: string;
+            anchored: boolean;
+            payload: Obj;
+        }[];
+    }[];
+    total: number;
+    pending_break_glass: number;
+    protocols: {
+        protocols: {
+            manifest_hash: unknown;
+            count: number;
+            first_ts: unknown;
+            last_ts: unknown;
+        }[];
+        deviations: number;
+        unprotocolled: number;
+    };
+    generated_at: string;
+};
+export declare function healthFindings(lines: readonly string[], bodies: (hash: string) => Uint8Array | undefined, closing?: boolean): {
+    code: string;
+    source: string;
+    severity: "warning" | "advisory";
+    ref: Record<string, string | number>;
+    detail: string;
+}[];
+export {};

package/dist/health/index.js

@@ -0,0 +1,233 @@
+// Health (spec/health.md): unlinkable per-episode patient tags, access and recommendation payloads,
+// clinician confirmations, loud break-glass, the protocol trail and the patient's pack, on Zanii's
+// health payloads (@zanii/health). Pure; mirrors sdks/python/src/zanii_blackbox/health.py; pinned
+// by spec/vectors/health.json.
+import { createHash, randomBytes } from "node:crypto";
+import { createConfirmation, jcsHash } from "@zanii/core";
+import { verifyConfirmation } from "../approvals/index.js";
+import { canonical } from "../reconcile/shared.js";
+const TAG = /^sha256:[0-9a-f]{64}$/;
+const HEX64 = /^[0-9a-f]{64}$/;
+/** The patient's seed, for the patient's own app. It never leaves the patient. */
+export function episodeSeed(secretHex) {
+    const secret = secretHex ?? randomBytes(32).toString("hex");
+    if (!HEX64.test(secret))
+        throw new Error("seed secret must be 32 bytes of hex");
+    return { v: 1, secret };
+}
+/** Zanii's tag for encounter n, derived by the patient; two tags can't be linked without the seed. */
+export function episodeTag(seed, n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error("n must be a non-negative integer");
+    return jcsHash({ v: 1, type: "episode_tag", secret: seed.secret, n });
+}
+/** The tag, or an error: the patient supplies the tag, never the seed. */
+export function checkEpisodeTag(tag) {
+    if ((typeof tag === "object" && tag !== null) || (typeof tag === "string" && HEX64.test(tag)))
+        throw new Error("pass the patient's episode tag, never the seed: whoever holds the seed can link every encounter");
+    if (typeof tag !== "string" || !TAG.test(tag))
+        throw new Error("episode_tag must be sha256: and 64 hex characters");
+    return tag;
+}
+const validTs = (ts) => typeof ts === "string" && !Number.isNaN(Date.parse(ts));
+const commit = (value, nonce) => `sha256:${createHash("sha256").update(Buffer.from(nonce, "hex")).update(canonical(value)).digest("hex")}`;
+/** A disclosed value and nonce match the commitment made at the time. */
+export const verifyCommitment = (value, nonce, commitment) => /^[0-9a-f]{32}$/.test(nonce) && commit(value, nonce) === commitment;
+const base = (kind) => ({ _zr_kind: "health", _zr_domain: "health", v: 1, kind });
+/** Zanii's health.access payload: who accessed the record, and why. */
+export function accessPayload(input) {
+    if (!input.actor)
+        throw new Error("actor is required");
+    if (!input.purpose)
+        throw new Error("purpose is required: purpose limitation is not optional");
+    if (!validTs(input.ts))
+        throw new Error("ts must be an ISO timestamp");
+    const nonce = input.nonce ?? randomBytes(16).toString("hex");
+    return {
+        payload: {
+            ...base("access"),
+            actor: input.actor,
+            purpose: input.purpose,
+            consent_ref: input.consentRef ?? null,
+            details_commitment: commit(input.details ?? {}, nonce),
+            ts: input.ts,
+        },
+        nonce,
+    };
+}
+/** What the clinician signs: jcsHash of the recommendation payload. */
+export const recommendationHash = (payload) => jcsHash(payload);
+/** Zanii's health.recommendation payload. No protocol, no recommendation; a deviation is recorded, never refused. */
+export function recommendationPayload(input) {
+    if (!input.modelId)
+        throw new Error("model_id is required");
+    if (!input.manifestHash)
+        throw new Error("manifest_hash is required: a clinical recommendation with no governing protocol on record is not auditable");
+    if (!validTs(input.ts))
+        throw new Error("ts must be an ISO timestamp");
+    const nonce = input.nonce ?? randomBytes(16).toString("hex");
+    const payload = {
+        ...base("recommendation"),
+        model_id: input.modelId,
+        runtime_hash: input.runtimeHash ?? null,
+        manifest_hash: input.manifestHash,
+        outcome_commitment: commit(input.outcome, nonce),
+        deviation: input.deviation ?? null,
+        ts: input.ts,
+    };
+    return { payload, nonce, hash: recommendationHash(payload) };
+}
+/** Zanii's health.confirmation payload, signed on the clinician's own device. */
+export function clinicianConfirmation(input) {
+    checkEpisodeTag(input.episodeTag);
+    const confirmation = createConfirmation({
+        ownerId: input.clinicianDid,
+        actionHash: input.recommendationHash,
+        confirmedAt: input.confirmedAt,
+    }, input.clinicianPrivateKey);
+    return {
+        ...base("confirmation"),
+        clinician: input.clinicianDid,
+        recommendation_hash: input.recommendationHash,
+        confirmation,
+        ts: input.confirmedAt,
+    };
+}
+const breakGlassAction = (tag, ts) => jcsHash({ v: 1, type: "break_glass", tag, ts });
+/** Zanii's health.break_glass payload: emergency access, signed personally. Kept open on purpose, and loud. */
+export function breakGlass(input) {
+    checkEpisodeTag(input.episodeTag);
+    if (!input.reason)
+        throw new Error("reason is required: an unexplained break-glass is exactly the abuse this exists to catch");
+    const confirmation = createConfirmation({
+        ownerId: input.clinicianDid,
+        actionHash: breakGlassAction(input.episodeTag, input.ts),
+        confirmedAt: input.ts,
+    }, input.clinicianPrivateKey);
+    return {
+        ...base("break_glass"),
+        clinician: input.clinicianDid,
+        reason: input.reason,
+        confirmation,
+        reviewed: false,
+        ts: input.ts,
+    };
+}
+/** A confirmation or break-glass is signed by the clinician it names, over the action it names. */
+export function verifyHealthSignature(payload, tag) {
+    const p = (payload ?? {});
+    const c = p.confirmation;
+    if (!c || typeof c !== "object")
+        return false;
+    if (c.owner_id !== p.clinician || !verifyConfirmation(c))
+        return false;
+    if (p.kind === "confirmation")
+        return c.action_hash === p.recommendation_hash;
+    if (p.kind === "break_glass")
+        return c.action_hash === breakGlassAction(tag, p.ts);
+    return false;
+}
+/** Zanii's protocol trail. No verdict on uniformity (individualised care is correct medicine). */
+export function protocolTrail(payloads) {
+    const recs = payloads
+        .filter((p) => typeof p === "object" && p !== null)
+        .filter((p) => p._zr_kind === "health" && p.kind === "recommendation")
+        .sort((a, b) => (String(a.ts) < String(b.ts) ? -1 : String(a.ts) > String(b.ts) ? 1 : 0));
+    const windows = new Map();
+    let deviations = 0;
+    let unprotocolled = 0;
+    for (const p of recs) {
+        if (p.deviation)
+            deviations++;
+        const h = p.manifest_hash;
+        if (!h) {
+            unprotocolled++;
+            continue;
+        }
+        const w = windows.get(String(h));
+        if (w) {
+            w.count++;
+            w.last_ts = p.ts;
+        }
+        else
+            windows.set(String(h), { manifest_hash: h, count: 1, first_ts: p.ts, last_ts: p.ts });
+    }
+    const protocols = [...windows.values()].sort((a, b) => String(a.first_ts) < String(b.first_ts) ? -1 : String(a.first_ts) > String(b.first_ts) ? 1 : 0);
+    return { protocols, deviations, unprotocolled };
+}
+/** spec/health.md §4: the patient's episodes; `reviewed` holds "<session_id>:<seq>" of reviewed break-glass. */
+export function episodesPack(items, o) {
+    const done = new Set(o.reviewed);
+    const episodes = o.tags
+        .map((tag) => ({
+        tag,
+        items: items.filter((i) => i.tag === tag).map(({ tag: _t, ...rest }) => rest),
+    }))
+        .filter((e) => e.items.length > 0);
+    const pending = items.filter((i) => i.payload.kind === "break_glass" && !done.has(`${i.session_id}:${i.seq}`));
+    return {
+        v: 1,
+        episodes,
+        total: items.length,
+        pending_break_glass: pending.length,
+        protocols: protocolTrail(items.map((i) => i.payload)),
+        generated_at: o.generated_at,
+    };
+}
+const decoder = new TextDecoder();
+export function healthFindings(lines, bodies, closing = false) {
+    const out = [];
+    const recommendations = [];
+    const confirmed = new Set();
+    let closed = closing;
+    for (const l of lines) {
+        const e = JSON.parse(l);
+        if (e.kind === "session.close")
+            closed = true;
+        if (e.kind !== "sdk.event" || !String(e.meta.type).startsWith("health."))
+            continue;
+        const body = bodies(e.body_hash);
+        let data = {};
+        try {
+            data = body ? JSON.parse(decoder.decode(body)) : {};
+        }
+        catch { }
+        const payload = data?.payload;
+        if (!payload || typeof payload !== "object")
+            continue;
+        const kind = payload.kind;
+        if (kind === "recommendation")
+            recommendations.push([e.seq, recommendationHash(payload)]);
+        else if (kind === "confirmation" || kind === "break_glass") {
+            if (!verifyHealthSignature(payload, String(data.episode_tag)))
+                out.push({
+                    code: "HEALTH_SIGNATURE_INVALID",
+                    source: "detectors",
+                    severity: "warning",
+                    ref: { seq: e.seq, kind },
+                    detail: "A clinician signature that isn't theirs, or signs another action.",
+                });
+            else if (kind === "confirmation")
+                confirmed.add(String(payload.recommendation_hash));
+            else
+                out.push({
+                    code: "BREAK_GLASS",
+                    source: "detectors",
+                    severity: "warning",
+                    ref: { seq: e.seq, clinician: String(payload.clinician) },
+                    detail: "Emergency access to a record, signed by the clinician.",
+                });
+        }
+    }
+    if (closed)
+        for (const [seq, h] of recommendations)
+            if (!confirmed.has(h))
+                out.push({
+                    code: "UNCONFIRMED_RECOMMENDATION",
+                    source: "detectors",
+                    severity: "advisory",
+                    ref: { seq, recommendation_hash: h },
+                    detail: "A model's recommendation no clinician confirmed.",
+                });
+    return out;
+}