@pfoundation/ocadvisor 26.9.1 → 26.9.2

package/dist/benchmarkStore.js

@@ -0,0 +1,308 @@
+// Local benchmark reader with hot reload: one store per plugin setup
+// watches the user snapshot and mappings files, serves a consistent
+// immutable view per consultation, and falls back through last-good data
+// to the bundled seed. Reload detection keys on file identity
+// (device/inode/size/mtime), so atomic replacements are observed even
+// when size and mtime are unchanged. The read path performs no network
+// I/O and never throws for missing or invalid data.
+import { open, stat as nodeStat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createBenchmarkMatcher, parseModelMappings, } from "./benchmarkMatch.js";
+import { parseBenchmarkSnapshot, verifySnapshotHash, } from "./benchmarkTypes.js";
+export const BENCHMARK_READ_MAX_BYTES = 16 * 1024 * 1024;
+export const BENCHMARK_FILE_TOO_LARGE = "BENCHMARK_FILE_TOO_LARGE";
+const READ_ATTEMPTS = 3;
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+export const DEFAULT_SEED_SNAPSHOT_PATH = join(MODULE_DIR, "data", "artificialAnalysis.snapshot.json");
+export const DEFAULT_SEED_MAPPINGS_PATH = join(MODULE_DIR, "data", "artificialAnalysis.mappings.json");
+function defaultFileSystem(maxBytes) {
+    return {
+        async stat(path) {
+            try {
+                const stats = await nodeStat(path);
+                return {
+                    dev: stats.dev,
+                    ino: stats.ino,
+                    size: stats.size,
+                    mtimeMs: stats.mtimeMs,
+                };
+            }
+            catch (error) {
+                if (error?.code === "ENOENT")
+                    return null;
+                throw error;
+            }
+        },
+        async read(path) {
+            const handle = await open(path, "r");
+            try {
+                const buffer = Buffer.alloc(maxBytes + 1);
+                const { bytesRead } = await handle.read(buffer, 0, maxBytes + 1, 0);
+                if (bytesRead > maxBytes) {
+                    const error = new Error(`benchmark file exceeds ${maxBytes} bytes`);
+                    error.code = BENCHMARK_FILE_TOO_LARGE;
+                    throw error;
+                }
+                return buffer.subarray(0, bytesRead).toString("utf8");
+            }
+            finally {
+                await handle.close();
+            }
+        },
+    };
+}
+function sameIdentity(a, b) {
+    return (a.dev === b.dev &&
+        a.ino === b.ino &&
+        a.size === b.size &&
+        a.mtimeMs === b.mtimeMs);
+}
+function signature(identity) {
+    return `${identity.dev}:${identity.ino}:${identity.size}:${identity.mtimeMs}`;
+}
+function errorCode(error) {
+    const code = error?.code;
+    return typeof code === "string" && code ? code : null;
+}
+// Reads a file only when two surrounding stats agree, so the bytes are
+// never cached under the wrong file identity. Atomic renames always yield
+// complete files; the loop only resolves which version was read.
+async function readStableFile(fs, path, maxBytes) {
+    for (let attempt = 0; attempt < READ_ATTEMPTS; attempt++) {
+        let before;
+        try {
+            before = await fs.stat(path);
+        }
+        catch (error) {
+            return {
+                kind: "unreadable",
+                reason: errorCode(error) ?? "unknown error",
+            };
+        }
+        if (before === null)
+            return { kind: "missing" };
+        if (before.size > maxBytes)
+            return { kind: "too_large" };
+        let text;
+        try {
+            text = await fs.read(path);
+        }
+        catch (error) {
+            const code = errorCode(error);
+            if (code === "ENOENT")
+                continue;
+            if (code === BENCHMARK_FILE_TOO_LARGE)
+                return { kind: "too_large" };
+            return { kind: "unreadable", reason: code ?? "unknown error" };
+        }
+        let after;
+        try {
+            after = await fs.stat(path);
+        }
+        catch (error) {
+            return {
+                kind: "unreadable",
+                reason: errorCode(error) ?? "unknown error",
+            };
+        }
+        if (after !== null && sameIdentity(before, after)) {
+            return { kind: "ok", identity: before, text };
+        }
+    }
+    return { kind: "unstable" };
+}
+function isValidationError(value) {
+    return typeof value === "object" && value !== null && "error" in value;
+}
+function freshTrackedFile() {
+    return { cached: null, rejected: null };
+}
+// Refreshes one watched user file. Unchanged and already-rejected
+// identities skip parsing; anything unusable retains the last good value
+// (or falls through to the seed leg) with an explicit diagnostic.
+async function refreshUserFile(args) {
+    const { fs, path, label, maxBytes, state, parse } = args;
+    const read = await readStableFile(fs, path, maxBytes);
+    if (read.kind === "missing") {
+        if (state.cached) {
+            return {
+                value: state.cached.value,
+                note: `${label} file was removed; retained last loaded data`,
+            };
+        }
+        return { value: null, note: null };
+    }
+    if (read.kind === "unstable") {
+        const note = `${label} file changed during read and never settled`;
+        if (state.cached)
+            return { value: state.cached.value, note };
+        return { value: null, note };
+    }
+    if (read.kind === "unreadable") {
+        const note = `${label} file is unreadable (${read.reason})`;
+        if (state.cached)
+            return { value: state.cached.value, note };
+        return { value: null, note };
+    }
+    if (read.kind === "too_large") {
+        const note = `${label} file exceeds the ${maxBytes} byte limit`;
+        if (state.cached)
+            return { value: state.cached.value, note };
+        return { value: null, note };
+    }
+    const sig = signature(read.identity);
+    if (state.cached && state.cached.signature === sig) {
+        return { value: state.cached.value, note: null };
+    }
+    if (state.rejected && state.rejected.signature === sig) {
+        if (state.cached) {
+            return { value: state.cached.value, note: state.rejected.reason };
+        }
+        return { value: null, note: state.rejected.reason };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        const reason = `${label} file is not valid JSON`;
+        state.rejected = { signature: sig, reason };
+        if (state.cached)
+            return { value: state.cached.value, note: reason };
+        return { value: null, note: reason };
+    }
+    const validated = parse(parsed);
+    if (isValidationError(validated)) {
+        const reason = `${label} file rejected: ${validated.error}`;
+        state.rejected = { signature: sig, reason };
+        if (state.cached)
+            return { value: state.cached.value, note: reason };
+        return { value: null, note: reason };
+    }
+    state.cached = { signature: sig, value: validated };
+    state.rejected = null;
+    return { value: validated, note: null };
+}
+async function loadSeedSnapshot(fs, path, maxBytes) {
+    const read = await readStableFile(fs, path, maxBytes);
+    // A missing seed is quiet: presence is a packaging assertion, and the
+    // store must work identically with user data or unavailable data.
+    if (read.kind === "missing" || read.kind === "unstable") {
+        return { value: null, note: null };
+    }
+    if (read.kind === "too_large") {
+        return {
+            value: null,
+            note: `seed snapshot exceeds the ${maxBytes} byte limit`,
+        };
+    }
+    if (read.kind === "unreadable") {
+        return {
+            value: null,
+            note: `seed snapshot is unreadable (${read.reason})`,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        return { value: null, note: "seed snapshot is not valid JSON" };
+    }
+    const validated = parseBenchmarkSnapshot(parsed);
+    if (isValidationError(validated)) {
+        return { value: null, note: `seed snapshot rejected: ${validated.error}` };
+    }
+    if (!verifySnapshotHash(validated)) {
+        return { value: validated, note: "seed snapshot hash mismatch" };
+    }
+    return { value: validated, note: null };
+}
+async function loadSeedMappings(fs, path, maxBytes) {
+    const empty = { schemaVersion: 1, bindings: [] };
+    const read = await readStableFile(fs, path, maxBytes);
+    if (read.kind === "missing" || read.kind === "unstable") {
+        return { value: empty, note: null };
+    }
+    if (read.kind === "too_large") {
+        return {
+            value: empty,
+            note: `seed mappings exceed the ${maxBytes} byte limit`,
+        };
+    }
+    if (read.kind === "unreadable") {
+        return {
+            value: empty,
+            note: `seed mappings are unreadable (${read.reason})`,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(read.text);
+    }
+    catch {
+        return { value: empty, note: "seed mappings are not valid JSON" };
+    }
+    const validated = parseModelMappings(parsed);
+    if (isValidationError(validated)) {
+        return { value: empty, note: `seed mappings rejected: ${validated.error}` };
+    }
+    return { value: validated, note: null };
+}
+export async function createBenchmarkStore(options) {
+    const maxBytes = options.maxBytes ?? BENCHMARK_READ_MAX_BYTES;
+    const fs = options.fs ?? defaultFileSystem(maxBytes);
+    const seedSnapshotPath = options.seedSnapshotPath ?? DEFAULT_SEED_SNAPSHOT_PATH;
+    const seedMappingsPath = options.seedMappingsPath ?? DEFAULT_SEED_MAPPINGS_PATH;
+    const seedSnapshot = await loadSeedSnapshot(fs, seedSnapshotPath, maxBytes);
+    const seedMappings = await loadSeedMappings(fs, seedMappingsPath, maxBytes);
+    const snapshotState = freshTrackedFile();
+    const mappingsState = freshTrackedFile();
+    return {
+        snapshotPath: options.snapshotPath,
+        mappingsPath: options.mappingsPath,
+        async view() {
+            const snapshotLeg = await refreshUserFile({
+                fs,
+                path: options.snapshotPath,
+                label: "benchmark snapshot",
+                maxBytes,
+                state: snapshotState,
+                parse: parseBenchmarkSnapshot,
+            });
+            const mappingsLeg = await refreshUserFile({
+                fs,
+                path: options.mappingsPath,
+                label: "model mappings",
+                maxBytes,
+                state: mappingsState,
+                parse: parseModelMappings,
+            });
+            const snapshot = snapshotLeg.value ?? seedSnapshot.value;
+            const snapshotSource = snapshotLeg.value
+                ? "user"
+                : seedSnapshot.value
+                    ? "seed"
+                    : "unavailable";
+            const snapshotNote = snapshotLeg.note ?? (snapshot ? null : seedSnapshot.note);
+            return {
+                snapshot,
+                snapshotSource,
+                snapshotPath: snapshotLeg.value ? options.snapshotPath : null,
+                snapshotNote,
+                snapshotHashVerified: snapshot ? verifySnapshotHash(snapshot) : false,
+                localMappings: mappingsLeg.value,
+                localMappingsNote: mappingsLeg.note,
+                bundledMappings: seedMappings.value,
+                bundledMappingsNote: seedMappings.note,
+                matcher: createBenchmarkMatcher({
+                    snapshot,
+                    bundled: seedMappings.value,
+                    local: mappingsLeg.value,
+                }),
+            };
+        },
+    };
+}
+//# sourceMappingURL=benchmarkStore.js.map

package/dist/benchmarkStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarkStore.js","sourceRoot":"","sources":["../src/benchmarkStore.ts"],"names":[],"mappings":"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"}

package/dist/benchmarkTypes.d.ts

@@ -0,0 +1,48 @@
+export declare const BENCHMARK_SCHEMA_VERSION = 1;
+export declare const BENCHMARK_SOURCE = "artificial-analysis";
+export declare const BENCHMARK_SOURCE_URL = "https://artificialanalysis.ai/";
+export type MetricCategory = "coding" | "general" | "reasoning" | "math";
+export type MetricUnit = "index_points" | "fraction";
+export interface MetricDefinition {
+    key: string;
+    label: string;
+    category: MetricCategory;
+    unit: MetricUnit;
+    higherIsBetter: boolean;
+    benchmarkVersion: string | null;
+}
+export interface BenchmarkModel {
+    id: string;
+    creatorID: string;
+    name: string;
+    slug: string;
+    evaluatedEffort: string | null;
+    evaluatedAt: string | null;
+    evaluations: Record<string, number | null>;
+}
+export interface BenchmarkSnapshot {
+    schemaVersion: 1;
+    source: "artificial-analysis";
+    sourceURL: string;
+    endpoint: string;
+    fetchedAt: string;
+    contentHash: string;
+    methodologyVersion: string | null;
+    metricDefinitions: MetricDefinition[];
+    models: BenchmarkModel[];
+}
+export declare const RECOGNIZED_METRICS: readonly MetricDefinition[];
+export declare const GATE_METRIC_ORDER: readonly string[];
+export type BenchmarkValidationError = {
+    error: string;
+};
+export declare function parseBenchmarkModel(value: unknown, label: string): BenchmarkModel | BenchmarkValidationError;
+export declare function parseBenchmarkSnapshot(value: unknown): BenchmarkSnapshot | BenchmarkValidationError;
+export declare function computeSnapshotHash(input: {
+    source: string;
+    endpoint: string;
+    methodologyVersion: string | null;
+    models: BenchmarkModel[];
+}): string;
+export declare function verifySnapshotHash(snapshot: BenchmarkSnapshot): boolean;
+//# sourceMappingURL=benchmarkTypes.d.ts.map

package/dist/benchmarkTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarkTypes.d.ts","sourceRoot":"","sources":["../src/benchmarkTypes.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,eAAO,MAAM,gBAAgB,wBAAwB,CAAC;AACtD,eAAO,MAAM,oBAAoB,mCAAmC,CAAC;AAErE,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,MAAM,CAAC;AACzE,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,UAAU,CAAC;AAErD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,cAAc,CAAC;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,CAAC,CAAC;IACjB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IAEjB,SAAS,EAAE,MAAM,CAAC;IAGlB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAMD,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EAyCzD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAE9C,CAAC;AAYF,MAAM,MAAM,wBAAwB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AA+DzD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,cAAc,GAAG,wBAAwB,CAwC3C;AA8DD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,wBAAwB,CAmE9C;AAkBD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B,GAAG,MAAM,CAYT;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CASvE"}

package/dist/benchmarkTypes.js

@@ -0,0 +1,298 @@
+// Versioned Artificial Analysis benchmark snapshot: shared schema,
+// validation, and content hashing for the updater, reader, CLI, and gate.
+//
+// One validation path serves downloads, the bundled seed, user snapshots,
+// and mapping-adjacent reads so every consumer agrees on what is usable.
+// Unknown additive fields are ignored or preserved (never invented), and
+// undocumented metadata stays null instead of guessed.
+import { createHash } from "node:crypto";
+export const BENCHMARK_SCHEMA_VERSION = 1;
+export const BENCHMARK_SOURCE = "artificial-analysis";
+export const BENCHMARK_SOURCE_URL = "https://artificialanalysis.ai/";
+// Recognized metrics in deterministic gate-selection order: the two
+// Artificial Analysis indexes first, then reasoning/math evidence. Scores
+// keep their published labels and units; index points and fractions are
+// never mixed into one aggregate.
+export const RECOGNIZED_METRICS = [
+    {
+        key: "artificial_analysis_coding_index",
+        label: "Artificial Analysis Coding Index",
+        category: "coding",
+        unit: "index_points",
+        higherIsBetter: true,
+        benchmarkVersion: null,
+    },
+    {
+        key: "artificial_analysis_intelligence_index",
+        label: "Artificial Analysis Intelligence Index",
+        category: "general",
+        unit: "index_points",
+        higherIsBetter: true,
+        benchmarkVersion: null,
+    },
+    {
+        key: "hle",
+        label: "HLE (Humanity's Last Exam)",
+        category: "reasoning",
+        unit: "fraction",
+        higherIsBetter: true,
+        benchmarkVersion: null,
+    },
+    {
+        key: "gpqa",
+        label: "GPQA",
+        category: "reasoning",
+        unit: "fraction",
+        higherIsBetter: true,
+        benchmarkVersion: null,
+    },
+    {
+        key: "artificial_analysis_math_index",
+        label: "Artificial Analysis Math Index",
+        category: "math",
+        unit: "index_points",
+        higherIsBetter: true,
+        benchmarkVersion: null,
+    },
+];
+export const GATE_METRIC_ORDER = RECOGNIZED_METRICS.map((metric) => metric.key);
+const RECOGNIZED_KEYS = new Set(GATE_METRIC_ORDER);
+const HASH_FORMAT = /^[0-9a-f]{64}$/;
+const CATEGORIES = [
+    "coding",
+    "general",
+    "reasoning",
+    "math",
+];
+const UNITS = ["index_points", "fraction"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidDateTime(value) {
+    return Number.isFinite(Date.parse(value));
+}
+function isValidationError(value) {
+    return typeof value === "object" && value !== null;
+}
+// `in` narrowing cannot discriminate an index-signature Record from the
+// error shape, so evaluations results use this predicate instead.
+function isParseError(value) {
+    return typeof value === "object" && value !== null && "error" in value;
+}
+function parseNullableString(value, field) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "string")
+        return { error: `${field} must be a string or null` };
+    return value;
+}
+// Recognized scores must be finite numbers or explicit nulls (zero is a
+// real score). Unknown keys keep finite numbers and nulls for forward
+// compatibility; anything else is ignored rather than rejected so additive
+// upstream changes cannot break previously valid snapshots.
+function parseEvaluations(value, label) {
+    if (value === null || value === undefined)
+        return {};
+    if (!isRecord(value)) {
+        return { error: `${label} evaluations must be an object` };
+    }
+    const evaluations = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry === null) {
+            evaluations[key] = null;
+            continue;
+        }
+        if (typeof entry !== "number" || !Number.isFinite(entry)) {
+            if (RECOGNIZED_KEYS.has(key)) {
+                return { error: `${label} has an invalid ${key} score` };
+            }
+            continue;
+        }
+        evaluations[key] = entry;
+    }
+    return evaluations;
+}
+export function parseBenchmarkModel(value, label) {
+    if (!isRecord(value)) {
+        return { error: `${label} must be an object` };
+    }
+    const id = typeof value.id === "string" ? value.id.trim() : "";
+    if (!id)
+        return { error: `${label} is missing a stable model id` };
+    const creatorID = typeof value.creatorID === "string" ? value.creatorID.trim() : "";
+    if (!creatorID)
+        return { error: `${label} is missing a creator id` };
+    if (typeof value.name !== "string" || typeof value.slug !== "string") {
+        return { error: `${label} is missing its name or slug` };
+    }
+    const evaluatedEffort = parseNullableString(value.evaluatedEffort, `${label} evaluatedEffort`);
+    if (isValidationError(evaluatedEffort))
+        return evaluatedEffort;
+    const evaluatedAt = parseNullableString(value.evaluatedAt, `${label} evaluatedAt`);
+    if (isValidationError(evaluatedAt))
+        return evaluatedAt;
+    if (typeof evaluatedAt === "string" &&
+        evaluatedAt.trim() &&
+        !isValidDateTime(evaluatedAt)) {
+        return { error: `${label} has an invalid evaluatedAt date` };
+    }
+    const evaluations = parseEvaluations(value.evaluations, label);
+    if (isParseError(evaluations))
+        return evaluations;
+    return {
+        id,
+        creatorID,
+        name: value.name,
+        slug: value.slug,
+        evaluatedEffort: evaluatedEffort,
+        evaluatedAt: evaluatedAt,
+        evaluations,
+    };
+}
+function parseMetricDefinitions(value) {
+    if (!Array.isArray(value)) {
+        return { error: "metricDefinitions must be an array" };
+    }
+    const seen = new Set();
+    const definitions = [];
+    for (let index = 0; index < value.length; index++) {
+        const entry = value[index];
+        const label = `metric definition ${index}`;
+        if (!isRecord(entry))
+            return { error: `${label} must be an object` };
+        const key = typeof entry.key === "string" ? entry.key.trim() : "";
+        if (!key)
+            return { error: `${label} is missing its key` };
+        if (seen.has(key)) {
+            return { error: `duplicate metric definition for ${key}` };
+        }
+        seen.add(key);
+        if (typeof entry.label !== "string") {
+            return { error: `${label} is missing its label` };
+        }
+        if (typeof entry.category !== "string" ||
+            !CATEGORIES.includes(entry.category)) {
+            return { error: `${label} has an unknown category` };
+        }
+        if (typeof entry.unit !== "string" || !UNITS.includes(entry.unit)) {
+            return { error: `${label} has an unknown unit` };
+        }
+        if (typeof entry.higherIsBetter !== "boolean") {
+            return { error: `${label} is missing higherIsBetter` };
+        }
+        const benchmarkVersion = parseNullableString(entry.benchmarkVersion, `${label} benchmarkVersion`);
+        if (isValidationError(benchmarkVersion))
+            return benchmarkVersion;
+        definitions.push({
+            key,
+            label: entry.label,
+            category: entry.category,
+            unit: entry.unit,
+            higherIsBetter: entry.higherIsBetter,
+            benchmarkVersion: benchmarkVersion,
+        });
+    }
+    return definitions;
+}
+function hasUsableScore(models) {
+    return models.some((model) => GATE_METRIC_ORDER.some((key) => typeof model.evaluations[key] === "number" &&
+        Number.isFinite(model.evaluations[key])));
+}
+export function parseBenchmarkSnapshot(value) {
+    if (!isRecord(value)) {
+        return { error: "benchmark snapshot must be an object" };
+    }
+    if (value.schemaVersion !== BENCHMARK_SCHEMA_VERSION) {
+        return {
+            error: `unsupported benchmark snapshot schema version ${String(value.schemaVersion)} (expected ${BENCHMARK_SCHEMA_VERSION})`,
+        };
+    }
+    if (value.source !== BENCHMARK_SOURCE) {
+        return {
+            error: `benchmark snapshot source must be ${BENCHMARK_SOURCE}`,
+        };
+    }
+    if (typeof value.sourceURL !== "string" || !value.sourceURL.trim()) {
+        return { error: "benchmark snapshot is missing its sourceURL" };
+    }
+    if (typeof value.endpoint !== "string" || !value.endpoint.trim()) {
+        return { error: "benchmark snapshot is missing its endpoint" };
+    }
+    if (typeof value.fetchedAt !== "string" ||
+        !isValidDateTime(value.fetchedAt)) {
+        return { error: "benchmark snapshot has an invalid fetchedAt timestamp" };
+    }
+    if (typeof value.contentHash !== "string" ||
+        !HASH_FORMAT.test(value.contentHash)) {
+        return { error: "benchmark snapshot has an invalid contentHash" };
+    }
+    const methodologyVersion = parseNullableString(value.methodologyVersion, "methodologyVersion");
+    if (isValidationError(methodologyVersion))
+        return methodologyVersion;
+    const metricDefinitions = parseMetricDefinitions(value.metricDefinitions);
+    if ("error" in metricDefinitions)
+        return metricDefinitions;
+    if (!Array.isArray(value.models) || value.models.length === 0) {
+        return { error: "benchmark snapshot has an empty model dataset" };
+    }
+    const seen = new Set();
+    const models = [];
+    for (let index = 0; index < value.models.length; index++) {
+        const parsed = parseBenchmarkModel(value.models[index], `model ${index}`);
+        if ("error" in parsed)
+            return parsed;
+        if (seen.has(parsed.id)) {
+            return { error: `duplicate benchmark model id ${parsed.id}` };
+        }
+        seen.add(parsed.id);
+        models.push(parsed);
+    }
+    if (!hasUsableScore(models)) {
+        return { error: "benchmark snapshot has no usable benchmark scores" };
+    }
+    return {
+        schemaVersion: BENCHMARK_SCHEMA_VERSION,
+        source: BENCHMARK_SOURCE,
+        sourceURL: value.sourceURL,
+        endpoint: value.endpoint,
+        fetchedAt: value.fetchedAt,
+        contentHash: value.contentHash,
+        methodologyVersion: methodologyVersion,
+        metricDefinitions,
+        models,
+    };
+}
+// Canonical JSON: object keys sorted recursively, arrays in order. Used only
+// for hashing, never for display.
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (isRecord(value)) {
+        const body = Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+            .join(",");
+        return `{${body}}`;
+    }
+    return JSON.stringify(value) ?? "null";
+}
+export function computeSnapshotHash(input) {
+    return createHash("sha256")
+        .update(stableStringify({
+        source: input.source,
+        endpoint: input.endpoint,
+        methodologyVersion: input.methodologyVersion,
+        models: input.models,
+    }), "utf8")
+        .digest("hex");
+}
+export function verifySnapshotHash(snapshot) {
+    return (computeSnapshotHash({
+        source: snapshot.source,
+        endpoint: snapshot.endpoint,
+        methodologyVersion: snapshot.methodologyVersion,
+        models: snapshot.models,
+    }) === snapshot.contentHash);
+}
+//# sourceMappingURL=benchmarkTypes.js.map