@qlm/learnlog-mcp 0.0.0-stage → 0.2.0

package/vendor/qlm-measure/cli.js

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+/**
+ * qlm-measure CLI — verify evidence records from the command line.
+ * verify makes no network calls. Records never leave your machine.
+ */
+import { readFileSync, writeFileSync, existsSync, realpathSync } from "fs";
+import { createHash } from "crypto";
+import { fileURLToPath } from "url";
+import { verifyRecord } from "./verifier/verify-record.js";
+import { verifyRecordV03 } from "./verifier-v03.js";
+import { verifyChain, listSchemes } from "./schemes/node.js";
+import { CATALOG, SHIPPED_CHECKS, SHIPPED_CHECKS_V03, PLANNED_CHECKS, CATALOG_BY_ID, CATEGORIES, CATEGORIES_V03 } from "./checks.js";
+const VERSION = "0.9.0";
+export const processIO = {
+    out: (text) => { process.stdout.write(text); },
+    err: (text) => { process.stderr.write(text); },
+    readStdin: () => readFileSync(0, "utf-8"),
+};
+/** The value when it is an array, else an empty list, so a malformed record is reported rather than crashing the report. */
+function listOf(value) {
+    return Array.isArray(value) ? value : [];
+}
+function baseName(path) {
+    return path.slice(path.lastIndexOf("/") + 1);
+}
+/** True for a record the 0.3 verifier handles: schemaVersion "0.3", or an evidence block. */
+function isV03Record(rec) {
+    return rec.schemaVersion === "0.3" || !!rec.evidence;
+}
+function hasPosteriorEntries(entries) {
+    return entries.some((e) => typeof e?.updatedPosterior === "number");
+}
+function hasRecordBody(item) {
+    const o = item;
+    return typeof o === "object" && o !== null && (!!o.entries || !!o.evidence);
+}
+function loadRecords(path, io) {
+    let raw;
+    if (path === "-") {
+        raw = io.readStdin();
+    }
+    else {
+        if (!existsSync(path))
+            throw new Error(`File not found: ${path}`);
+        raw = readFileSync(path, "utf-8");
+    }
+    // Strip BOM
+    if (raw.charCodeAt(0) === 0xFEFF)
+        raw = raw.slice(1);
+    raw = raw.trim();
+    if (!raw)
+        throw new Error(`${path}: empty input`);
+    if (raw[0] === "[") {
+        const arr = JSON.parse(raw);
+        for (const item of arr) {
+            if (!hasRecordBody(item))
+                throw new Error(`${path}: element missing entries`);
+        }
+        return arr;
+    }
+    if (raw[0] === "{") {
+        // Try as single JSON object first
+        try {
+            const obj = JSON.parse(raw);
+            if (hasRecordBody(obj))
+                return [obj];
+        }
+        catch { /* not a single object, try JSONL */ }
+        // JSONL: multiple JSON objects, one per line
+        const lines = raw.split("\n").filter(l => l.trim());
+        if (lines.length > 1 && lines.every(l => l.trim().startsWith("{"))) {
+            return lines.map((line, i) => {
+                const obj = JSON.parse(line);
+                if (!hasRecordBody(obj))
+                    throw new Error(`${path}: line ${i + 1} missing entries`);
+                return obj;
+            });
+        }
+        throw new Error(`${path}: could not parse as JSON or JSONL`);
+    }
+    throw new Error(`${path}: unrecognized format`);
+}
+// ── Report ──────────────────────────────────────────────────
+function buildReport(path, records, results) {
+    const sha = path !== "-" && existsSync(path)
+        ? createHash("sha256").update(readFileSync(path)).digest("hex") : "";
+    const recordReports = records.map((rec, i) => {
+        const result = results[i];
+        const isV03 = isV03Record(rec);
+        const checksList = isV03 ? SHIPPED_CHECKS_V03 : SHIPPED_CHECKS;
+        const entries03 = isV03 ? listOf(rec.evidence?.entries) : listOf(rec.entries);
+        const hasCompaction = !!rec.compactedBefore || !!rec.evidence?.compactedBefore;
+        const hasPosteriors = hasPosteriorEntries(entries03);
+        const violsByCheck = {};
+        for (const v of result.violations) {
+            const cid = v.checkId;
+            (violsByCheck[cid] ??= []).push(v);
+        }
+        const checks = checksList.map(def => {
+            const vlist = violsByCheck[def.id] || [];
+            let status;
+            if (def.id === "COMPACTION.BOUNDARY" && !hasCompaction)
+                status = "not_applicable";
+            else if (def.id === "POSTERIOR.CHAIN" && !hasPosteriors)
+                status = "not_applicable";
+            else if (vlist.length > 0)
+                status = "fail";
+            else
+                status = "pass";
+            const entry = { id: def.id, status, failures: vlist.length };
+            if (vlist.length > 0)
+                entry.first_failure = { version: vlist[0].version, message: vlist[0].message };
+            return entry;
+        });
+        return {
+            studentScopeId: rec.studentScopeId || "",
+            schemaVersion: rec.schemaVersion || "0.2",
+            entries_checked: result.entriesChecked,
+            valid: result.valid,
+            checks,
+            violations: result.violations.map(v => ({
+                version: v.version, check_id: v.checkId,
+                category: v.category, message: v.message,
+            })),
+        };
+    });
+    const summary = {
+        records: records.length,
+        valid: results.filter(r => r.valid).length,
+        invalid: results.filter(r => !r.valid).length,
+        checks_run: 0, checks_passed: 0, checks_failed: 0, checks_not_applicable: 0,
+    };
+    for (const rr of recordReports) {
+        for (const c of rr.checks) {
+            if (c.status === "not_applicable")
+                summary.checks_not_applicable++;
+            else {
+                summary.checks_run++;
+                if (c.status === "pass")
+                    summary.checks_passed++;
+                else
+                    summary.checks_failed++;
+            }
+        }
+    }
+    return {
+        tool: { name: "qlm-measure", version: VERSION, language: "javascript", catalog_version: "1" },
+        input: { path: baseName(path), sha256: sha, records: records.length },
+        generated_at: new Date().toISOString().replace(/\.\d+Z$/, "Z"),
+        records: recordReports,
+        summary,
+    };
+}
+function formatText(path, records, results) {
+    const lines = [];
+    const filename = baseName(path);
+    lines.push(`qlm-measure verify ${filename}`);
+    lines.push(`records: ${records.length}`);
+    for (let i = 0; i < records.length; i++) {
+        const rec = records[i];
+        const result = results[i];
+        const isV03_t = isV03Record(rec);
+        const checksList_t = isV03_t ? SHIPPED_CHECKS_V03 : SHIPPED_CHECKS;
+        const categories_t = isV03_t ? CATEGORIES_V03 : CATEGORIES;
+        const entries_t = isV03_t ? listOf(rec.evidence?.entries) : listOf(rec.entries);
+        const hasCompaction = !!rec.compactedBefore || !!rec.evidence?.compactedBefore;
+        const hasPosteriors_t = hasPosteriorEntries(entries_t);
+        const violsByCheck = {};
+        for (const v of result.violations) {
+            const cid = v.checkId;
+            (violsByCheck[cid] ??= []).push(v);
+        }
+        lines.push("");
+        lines.push(`record ${rec.studentScopeId || "?"}  (schema ${rec.schemaVersion || "0.2"}, ${listOf(rec.entries || rec.evidence?.entries).length} entries)`);
+        for (const cat of categories_t) {
+            lines.push(`  ${cat}`);
+            for (const def of checksList_t.filter(c => c.category === cat)) {
+                const vlist = violsByCheck[def.id] || [];
+                if (def.id === "COMPACTION.BOUNDARY" && !hasCompaction) {
+                    lines.push(`    \u2013 ${def.label}  (not applicable)`);
+                }
+                else if (def.id === "POSTERIOR.CHAIN" && !hasPosteriors_t) {
+                    lines.push(`    \u2013 ${def.label}  (not applicable)`);
+                }
+                else if (vlist.length > 0) {
+                    const first = vlist[0];
+                    const detail = `${vlist.length} failure${vlist.length > 1 ? "s" : ""}; first at v${first.version}: ${first.message}`;
+                    lines.push(`    \u2717 ${def.label}  (${detail})`);
+                }
+                else {
+                    lines.push(`    \u2713 ${def.label}`);
+                }
+            }
+        }
+        const nv = result.violations.length;
+        lines.push(`  violations: ${nv}`);
+        if (result.valid)
+            lines.push("  VERDICT: CLEAN \u2014 record is verifiable");
+        else
+            lines.push(`  VERDICT: NOT CLEAN \u2014 ${nv} violation(s); see report`);
+    }
+    const report = buildReport(path, records, results);
+    const s = report.summary;
+    lines.push("");
+    lines.push(`summary: ${s.records} record(s), ${s.valid} valid, ${s.invalid} invalid; checks run ${s.checks_run}, passed ${s.checks_passed}, failed ${s.checks_failed}, not applicable ${s.checks_not_applicable}`);
+    return lines.join("\n") + "\n";
+}
+// ── Commands ────────────────────────────────────────────────
+/**
+ * Options the Python CLI has and this CLI does not implement. They stop with an
+ * error rather than being accepted and silently ignored.
+ */
+const UNSUPPORTED_VERIFY_OPTIONS = new Set(["--redact", "--tolerance-ms"]);
+class UsageError extends Error {
+}
+function cmdVerify(args, io) {
+    let format = "text";
+    let reportFile = null;
+    let quiet = false;
+    const paths = [];
+    try {
+        for (let i = 0; i < args.length; i++) {
+            const a = args[i];
+            if (a === "--format") {
+                format = args[++i];
+                if (format !== "text" && format !== "json")
+                    throw new UsageError("--format must be text or json");
+            }
+            else if (a === "--report") {
+                const next = args[++i];
+                if (next === undefined)
+                    throw new UsageError("--report needs a file name");
+                reportFile = next;
+            }
+            else if (a === "--quiet") {
+                quiet = true;
+            }
+            else if (UNSUPPORTED_VERIFY_OPTIONS.has(a)) {
+                throw new UsageError(`${a} is not supported by the JavaScript CLI; the Python CLI (python/qlm_measure) supports it`);
+            }
+            else if (a.startsWith("--")) {
+                throw new UsageError(`unknown option: ${a}`);
+            }
+            else {
+                paths.push(a);
+            }
+        }
+    }
+    catch (e) {
+        io.err(`error: ${e.message}\n`);
+        return 2;
+    }
+    if (paths.length === 0) {
+        io.err("error: no files specified\n");
+        return 2;
+    }
+    const allRecords = [];
+    const allResults = [];
+    for (const p of paths) {
+        try {
+            const records = loadRecords(p, io);
+            for (const r of records) {
+                allRecords.push(r);
+                // Dispatch by schema version
+                if (isV03Record(r)) {
+                    const r03 = verifyRecordV03(r);
+                    allResults.push({ valid: r03.valid, violations: r03.violations.map(v => ({
+                            version: v.version, category: v.category, message: v.message, checkId: v.checkId,
+                        })), entriesChecked: r03.entriesChecked });
+                }
+                else {
+                    allResults.push(verifyRecord(r));
+                }
+            }
+        }
+        catch (e) {
+            io.err(`error: ${e.message}\n`);
+            return 2;
+        }
+    }
+    if (allRecords.length === 0) {
+        io.err("error: no records loaded\n");
+        return 2;
+    }
+    const label = paths.length === 1 ? paths[0] : `${paths.length} files`;
+    if (format === "json" || reportFile) {
+        const report = buildReport(label, allRecords, allResults);
+        const json = JSON.stringify(report, null, 2);
+        if (reportFile)
+            writeFileSync(reportFile, json + "\n");
+        if (format === "json")
+            io.out(json + "\n");
+        else if (!quiet)
+            io.out(formatText(label, allRecords, allResults));
+    }
+    else if (!quiet) {
+        io.out(formatText(label, allRecords, allResults));
+    }
+    return allResults.some(r => !r.valid) ? 1 : 0;
+}
+function cmdExplain(args, io) {
+    const say = (line = "") => io.out(line + "\n");
+    const checkId = args[0];
+    if (checkId) {
+        const def = CATALOG_BY_ID[checkId];
+        if (!def) {
+            io.err(`error: unknown check ID: ${checkId}\n`);
+            io.err(`Available: ${CATALOG.map(c => c.id).join(", ")}\n`);
+            return 2;
+        }
+        say(`${def.id} — ${def.label}`);
+        say(`  Status:    ${def.status}`);
+        say(`  Category:  ${def.category}`);
+        say(`  Scope:     ${def.scope}`);
+        say(`  Since:     ${def.introducedIn}`);
+        say();
+        say(`  ${def.description}`);
+        say();
+        say(`  How to pass: ${def.howToPass}`);
+    }
+    else {
+        say("qlm-measure check catalog (v1)");
+        say();
+        say("Shipped checks (run by verify):");
+        for (const c of SHIPPED_CHECKS)
+            say(`  ${c.id.padEnd(28)} ${c.label}`);
+        say();
+        say("Planned checks (listed, not run):");
+        for (const c of PLANNED_CHECKS)
+            say(`  ${c.id.padEnd(28)} ${c.label}`);
+        say();
+        say("Use 'qlm-measure explain CHECK_ID' for details.");
+    }
+    return 0;
+}
+function cmdVersion(io) {
+    io.out(`qlm-measure ${VERSION}\n`);
+    io.out("schema version: 0.2\n");
+    io.out("catalog version: 1\n");
+    return 0;
+}
+// ── verify-chain: per-event hash chains sealed by QLM products ─────────────
+function cmdVerifyChain(argv, io) {
+    const say = (line) => io.out(line + "\n");
+    const fail = (line) => { io.err(line + "\n"); return 2; };
+    const opts = { format: "text", allowMixed: false, list: false };
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--family" || a === "--scheme") {
+            const v = argv[++i];
+            if (v === undefined)
+                return fail(`ERROR: ${a} needs a value`);
+            opts[a === "--family" ? "family" : "scheme"] = v;
+        }
+        else if (a === "--format") {
+            opts.format = argv[++i];
+            if (opts.format !== "text" && opts.format !== "json")
+                return fail("ERROR: --format must be text or json");
+        }
+        else if (a === "--allow-mixed") {
+            opts.allowMixed = true;
+        }
+        else if (a === "--list") {
+            opts.list = true;
+        }
+        else if (a.startsWith("--")) {
+            return fail(`ERROR: unknown option: ${a}`);
+        }
+        else
+            positional.push(a);
+    }
+    if (opts.list) {
+        for (const s of listSchemes())
+            say(`${s.id}\t${s.family}\tsince ${s.since}\t${s.hashField}/${s.prevField}`);
+        return 0;
+    }
+    const file = positional[0];
+    if (!file)
+        return fail("Usage: qlm-measure verify-chain <events.json> (--family F | --scheme S) [--allow-mixed] [--format text|json] | --list");
+    if (!opts.family && !opts.scheme)
+        return fail("ERROR: pass --family (e.g. tpc/clinical) or --scheme (e.g. tpc/clinical-v2)");
+    if (!existsSync(file))
+        return fail(`ERROR: ${file} not found`);
+    let events;
+    try {
+        events = JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch (e) {
+        return fail(`ERROR: parse failed: ${e}`);
+    }
+    if (!Array.isArray(events) && events && typeof events === "object" && Array.isArray(events.events)) {
+        events = events.events; // { events: [...] } wrapper (vectors, exports with metadata)
+    }
+    if (!Array.isArray(events))
+        return fail("ERROR: not an array of events (or an object with an events array)");
+    let r;
+    try {
+        r = verifyChain(events, { family: opts.family, scheme: opts.scheme, rejectMixed: !opts.allowMixed });
+    }
+    catch (e) {
+        return fail(`ERROR: ${e.message}`);
+    }
+    if (opts.format === "json") {
+        say(JSON.stringify({ verifier: `qlm-measure ${VERSION}`, file, ...r }, null, 2));
+        return r.clean ? 0 : 1;
+    }
+    say(`qlm-measure verify-chain ${VERSION}`);
+    say(`file: ${file}`);
+    say(`timestamp: ${new Date().toISOString()}`);
+    say(`result: ${r.clean ? "CLEAN" : "FAIL"}`);
+    say(`events: ${r.stats.total}`);
+    say(`gaps: ${r.stats.gaps}`);
+    say(`duplicates: ${r.stats.duplicates}`);
+    say(`tampered: ${r.stats.tampered}`);
+    say(`schema_errors: ${r.stats.schema_errors}`);
+    say(`hash_scheme: ${r.stats.hash_scheme}`);
+    say(`schemes: ${JSON.stringify(r.stats.schemes)}`);
+    if (!r.clean) {
+        say("\nerrors:");
+        r.errors.forEach((e) => say(`  ${e}`));
+    }
+    return r.clean ? 0 : 1;
+}
+// ── Main ────────────────────────────────────────────────────
+const USAGE = [
+    "Usage: qlm-measure <verify|verify-chain|explain|version> [options]",
+    "  verify PATH... [--format text|json] [--report FILE] [--quiet]",
+    "  verify-chain EVENTS_JSON (--family F | --scheme S) [--allow-mixed] [--format text|json]",
+    "  verify-chain --list",
+    "  explain [CHECK_ID]",
+    "  version",
+    "",
+].join("\n");
+/** Runs one CLI invocation and returns its exit code: 0 clean, 1 not clean, 2 usage or input error. */
+export function main(argv, io = processIO) {
+    const [cmd, ...rest] = argv;
+    switch (cmd) {
+        case "verify": return cmdVerify(rest, io);
+        case "verify-chain": return cmdVerifyChain(rest, io);
+        case "explain": return cmdExplain(rest, io);
+        case "version": return cmdVersion(io);
+        default:
+            io.out(USAGE);
+            return 2;
+    }
+}
+/** True when this module is the script node was started with, including through npm's bin symlink. */
+export function isDirectRun(scriptPath, moduleUrl) {
+    if (!scriptPath)
+        return false;
+    try {
+        return realpathSync(scriptPath) === realpathSync(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectRun(process.argv[1], import.meta.url))
+    process.exit(main(process.argv.slice(2)));
+//# sourceMappingURL=cli.js.map

package/vendor/qlm-measure/rules.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Public update rule registry.
+ * Each rule is a pure function: given inputs, produce a posterior.
+ * This module ships with the SDK and has no server dependency.
+ */
+export type RuleFn = (prior: number, correct: boolean, weight: number, params: Record<string, number>) => number;
+export declare function registerRule(ruleId: string, fn: RuleFn): void;
+export declare function getRule(ruleId: string): RuleFn | undefined;
+export declare function reproduce(ruleId: string, params: Record<string, number>, prior: number, correct: boolean, weight: number): number | null;
+//# sourceMappingURL=rules.d.ts.map

package/vendor/qlm-measure/rules.js

@@ -0,0 +1,46 @@
+/**
+ * Public update rule registry.
+ * Each rule is a pure function: given inputs, produce a posterior.
+ * This module ships with the SDK and has no server dependency.
+ */
+const registry = new Map();
+export function registerRule(ruleId, fn) {
+    registry.set(ruleId, fn);
+}
+export function getRule(ruleId) {
+    return registry.get(ruleId);
+}
+export function reproduce(ruleId, params, prior, correct, weight) {
+    const fn = getRule(ruleId);
+    if (!fn)
+        return null;
+    return fn(prior, correct, weight, params);
+}
+// ── tempered-bkt-1 ─────────────────────────────────────────
+// Written from depth_engine/update.py. Spec: rules/tempered-bkt-1.md
+function temperedBkt1(prior, correct, weight, params) {
+    const slip = params.slip;
+    const guess = params.guess;
+    if (prior <= 0 || prior >= 1)
+        throw new Error(`prior must be in (0, 1), got ${prior}`);
+    if (weight < 0 || weight > 1)
+        throw new Error(`weight must be in [0, 1], got ${weight}`);
+    if (weight === 0)
+        return prior;
+    let pObsMastered;
+    let pObsNotMastered;
+    if (correct) {
+        pObsMastered = Math.pow(1 - slip, weight);
+        pObsNotMastered = Math.pow(guess, weight);
+    }
+    else {
+        pObsMastered = Math.pow(slip, weight);
+        pObsNotMastered = Math.pow(1 - guess, weight);
+    }
+    const numerator = prior * pObsMastered;
+    const denominator = numerator + (1 - prior) * pObsNotMastered;
+    const posterior = numerator / denominator;
+    return Math.max(1e-15, Math.min(1 - 1e-15, posterior));
+}
+registerRule("tempered-bkt-1", temperedBkt1);
+//# sourceMappingURL=rules.js.map

package/vendor/qlm-measure/schemes/index.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Chain schemes — one implementation of every per-event hash chain a QLM
+ * product seals.
+ *
+ * Products store one row per event with a hash field and a link to the
+ * previous event's hash. Historically each product computed that hash with
+ * its own copy of the code; when one copy changed (TeachProof, 2026-09-10:
+ * 10 → 12 hashed fields) the standalone verifier did not, and every sealed
+ * chain read as "tampered". This module makes each scheme a named,
+ * versioned definition with a canonical serialization, so the sealer and
+ * every verifier — in TypeScript or Python — hash the same bytes.
+ *
+ * This file is pure: no Node or browser APIs. Hashing is injected, so the
+ * same code runs server-side (`./node.js`) and in a client component.
+ * Python twin: `python/qlm_measure/schemes.py`. Both are checked against
+ * `schema/vectors/chains/*.json`.
+ */
+export type HashFn = (canonical: string) => string;
+export type AsyncHashFn = (canonical: string) => Promise<string>;
+export type ChainEvent = Record<string, unknown>;
+export type Digest = "sha256" | "fnv1a64" | "djb2-32";
+export interface ChainScheme {
+    /** Stable identifier, e.g. "tpc/clinical-v2". */
+    id: string;
+    /** Schemes in one family share storage and a link convention; detection walks the family newest-first. */
+    family: string;
+    /** ISO date the scheme entered production. */
+    since: string;
+    /** Field carrying this event's hash. */
+    hashField: string;
+    /**
+     * Field carrying the previous event's hash, or null when the record stores no
+     * link field. With `link: "implicit"` the previous hash still enters the
+     * canonical form (threaded from the previous record); with `link: "none"`
+     * the scheme is a content hash and records are independent.
+     */
+    prevField: string | null;
+    /** Value of `prevField` on the first event; null means absent/null is the genesis. */
+    genesis: string | null;
+    /** How records bind to their predecessor. Default: "explicit" when prevField is set, else "none". */
+    link?: "explicit" | "implicit" | "none";
+    /** Digest over the canonical string. Default sha256 (injected); the others are built in. */
+    digest?: Digest;
+    /** Keep only the first N hex characters of the digest (play/measure-session stores 32). */
+    truncate?: number;
+    /** Written before the digest in the hash field ("sha256:" for yardstick/depth-1). */
+    prefix?: string;
+    /** Structural precondition for trying this scheme on an event. */
+    applies(event: ChainEvent): boolean;
+    /**
+     * The exact string that is hashed. Never includes `hashField`. `prev` is the
+     * previous record's stored hash (the genesis value for the first record);
+     * schemes with an explicit link normally read the event's own field instead.
+     */
+    canonical(event: ChainEvent, prev?: string): string;
+    /** Schema errors for one event (not integrity errors). Empty when valid. */
+    validate(event: ChainEvent): string[];
+    /** Scheme ids that may appear in the same chain as this one without the chain counting as mixed. */
+    coexists?: string[];
+}
+export declare function linkOf(s: ChainScheme): "explicit" | "implicit" | "none";
+/** FNV-1a 64-bit over UTF-16 code units, 16 hex chars (qlm-games snapshot-commit hashSnapshotSync). */
+export declare function fnv1a64Hex(str: string): string;
+/** djb2, 32-bit wrap, unsigned hex padded to 8 (q-core evidence-chain hashString). */
+export declare function djb2Hex(str: string): string;
+/** The digest a scheme seals with: built in for fnv/djb2, the injected function for sha256. */
+export declare function digestFor(scheme: ChainScheme, sha256: HashFn): HashFn;
+/** Recursively sorts object keys; arrays keep their order. Mirrors Play's residency canonicalize(). */
+export declare function sortKeysDeep(value: unknown): unknown;
+export declare const TPC_SIGNALS: readonly ["demonstrated", "partial", "missed_opportunity", "not_observable"];
+export declare const TPC_CLINICAL_V1: ChainScheme;
+/** 2026-09-10 (teachproof ac9375b): triage_class and engine_version join the hash, null when absent. */
+export declare const TPC_CLINICAL_V2: ChainScheme;
+/** 2026-09-14: mapping_version joins the hash on events that carry it. */
+export declare const TPC_CLINICAL_V3: ChainScheme;
+/**
+ * 2026-09-25 (teachproof schema 0.4, TPC-SPEC-002 A6): an event may carry
+ * event_kind ("chart.view", "chart.item", ...) and a per-kind payload. Both
+ * join the hash: the v3 fields (mapping_version null when absent), then
+ * event_kind, then the payload with its keys sorted at every depth. Only
+ * events with event_kind use it; the rest of the chain stays v3.
+ */
+export declare const TPC_CLINICAL_V4: ChainScheme;
+export declare const PLAY_CLINICAL_1_0: ChainScheme;
+export declare const SCHEMES: Readonly<Record<string, ChainScheme>>;
+export declare function getScheme(id: string): ChainScheme;
+/** Schemes of a family, newest first — the order detection tries them in. */
+export declare function familySchemes(family: string): ChainScheme[];
+export declare function listSchemes(): Array<Pick<ChainScheme, "id" | "family" | "since" | "hashField" | "prevField"> & {
+    link: string;
+    digest: Digest;
+}>;
+export declare function computeEventHashWith(hash: HashFn, event: ChainEvent, schemeId: string, prev?: string): string;
+export declare function computeEventHashAsyncWith(hash: AsyncHashFn, event: ChainEvent, schemeId: string, prev?: string): Promise<string>;
+/**
+ * Returns a copy of `event` with the scheme's hash field set. Never mutates the
+ * input. `prev` is required for implicit-link schemes (the previous record's
+ * hash, or the genesis value for the first record).
+ */
+export declare function sealEventWith<E extends ChainEvent>(hash: HashFn, event: E, schemeId: string, prev?: string): E;
+/** Which scheme of `family` the event's stored hash was sealed under, or null. Tries newest first. */
+export declare function detectSchemeWith(hash: HashFn, event: ChainEvent, family: string, prev?: string): string | null;
+export interface ChainVerification {
+    clean: boolean;
+    errors: string[];
+    stats: {
+        total: number;
+        gaps: number;
+        duplicates: number;
+        tampered: number;
+        schema_errors: number;
+        /** Scheme id when the whole chain is sealed under one scheme; "mixed"; or "none" for an empty chain. */
+        hash_scheme: string;
+        /** Events per detected scheme id. */
+        schemes: Record<string, number>;
+    };
+}
+export interface VerifyChainOptions {
+    /** Detect the scheme per event within this family (default when `scheme` is not given). */
+    family?: string;
+    /** Require exactly this scheme for every event. */
+    scheme?: string;
+    /** Treat a chain that mixes schemes as an error (default true). */
+    rejectMixed?: boolean;
+}
+/**
+ * The path of the first own "__proto__" key at any depth (".payload.__proto__"), or null.
+ * sortKeysDeep drops such a key, as the products' original code did, so no hash covers it;
+ * verifyChain refuses an event that holds one rather than verify content the hash does not cover.
+ */
+export declare function protoKeyPath(value: unknown, path?: string): string | null;
+export declare function verifyChainWith(hash: HashFn, events: ChainEvent[], opts: VerifyChainOptions): ChainVerification;
+//# sourceMappingURL=index.d.ts.map