@pfoundation/ocadvisor 26.9.1 → 26.9.3

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

package/dist/benchmarkTypes.js.map

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

package/dist/benchmarkUpdate.d.ts

@@ -0,0 +1,33 @@
+export declare const AA_API_KEY_ENV = "ARTIFICIAL_ANALYSIS_API_KEY";
+export declare const BENCHMARK_UPDATE_TIMEOUT_MS = 30000;
+export declare const BENCHMARK_UPDATE_MAX_BYTES: number;
+export type BenchmarkUpdateErrorCode = "missing_key" | "invalid_path" | "timeout" | "too_large" | "http" | "transport" | "invalid_response" | "busy" | "write_failed";
+export interface BenchmarkUpdateSuccess {
+    ok: true;
+    path: string;
+    fetchedAt: string;
+    modelCount: number;
+    contentHash: string;
+    unchanged: boolean;
+    metricCoverage: Record<string, number>;
+}
+export interface BenchmarkUpdateFailure {
+    ok: false;
+    code: BenchmarkUpdateErrorCode;
+    message: string;
+    status?: number;
+}
+export type BenchmarkUpdateResult = BenchmarkUpdateSuccess | BenchmarkUpdateFailure;
+export interface BenchmarkUpdateDeps {
+    fetchImpl?: typeof fetch;
+    env?: Record<string, string | undefined>;
+    apiKey?: string;
+    now?: () => string;
+    timeoutMs?: number;
+    maxBytes?: number;
+    randomId?: () => string;
+    currentPid?: number;
+    processAlive?: (pid: number) => boolean;
+}
+export declare function updateBenchmarkSnapshot(targetPath: string, deps?: BenchmarkUpdateDeps): Promise<BenchmarkUpdateResult>;
+//# sourceMappingURL=benchmarkUpdate.d.ts.map

package/dist/benchmarkUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarkUpdate.d.ts","sourceRoot":"","sources":["../src/benchmarkUpdate.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,cAAc,gCAAgC,CAAC;AAC5D,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAClD,eAAO,MAAM,0BAA0B,QAAmB,CAAC;AAE3D,MAAM,MAAM,wBAAwB,GAChC,aAAa,GACb,cAAc,GACd,SAAS,GACT,WAAW,GACX,MAAM,GACN,WAAW,GACX,kBAAkB,GAClB,MAAM,GACN,cAAc,CAAC;AAEnB,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,KAAK,CAAC;IACV,IAAI,EAAE,wBAAwB,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,qBAAqB,GAC/B,sBAAsB,GAAG,sBAAsB,CAAC;AAElD,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAwLD,wBAAsB,uBAAuB,CAC3C,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE,mBAAwB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAyIhC"}

package/dist/benchmarkUpdate.js

@@ -0,0 +1,327 @@
+// Transactional Artificial Analysis snapshot refresh: one bounded,
+// authenticated fetch is validated, staged next to the target, and
+// atomically renamed over it. Any failure before the rename leaves the
+// previous file byte-for-byte intact. A per-target PID lock coordinates
+// concurrent updaters; stale locks from dead processes are recovered,
+// live locks fail promptly with `busy`.
+import { mkdir, open, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join } from "node:path";
+import { AA_LLM_MODELS_ENDPOINT, normalizeAAResponse, } from "./artificialAnalysis.js";
+import { RECOGNIZED_METRICS, } from "./benchmarkTypes.js";
+export const AA_API_KEY_ENV = "ARTIFICIAL_ANALYSIS_API_KEY";
+export const BENCHMARK_UPDATE_TIMEOUT_MS = 30_000;
+export const BENCHMARK_UPDATE_MAX_BYTES = 16 * 1024 * 1024;
+function defaultProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultRandomId() {
+    return `${process.pid}.${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 10)}`;
+}
+function lockPathFor(targetPath) {
+    return `${targetPath}.lock`;
+}
+function stagePrefixFor(targetPath) {
+    return `.${basename(targetPath)}.`;
+}
+// Removes interrupted staging files for this target left by crashed runs.
+// Other targets sharing the directory use a different prefix and are kept.
+async function reapStaleStaging(targetPath) {
+    const dir = dirname(targetPath);
+    const prefix = stagePrefixFor(targetPath);
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!name.startsWith(prefix) || !name.endsWith(".tmp"))
+            continue;
+        try {
+            await rm(join(dir, name), { force: true });
+        }
+        catch { }
+    }
+}
+async function readLockPid(lockPath) {
+    try {
+        const raw = await readFile(lockPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const pid = parsed.pid;
+        return typeof pid === "number" && Number.isInteger(pid) && pid > 0
+            ? pid
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Acquires the per-target lock. Returns true when held; a live holder means
+// `busy`, while a dead or corrupt holder is removed and acquisition retried
+// once (losing a takeover race still reports `busy`).
+async function acquireLock(lockPath, currentPid, processAlive, fetchedAt) {
+    const payload = JSON.stringify({ pid: currentPid, createdAt: fetchedAt });
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            await writeFile(lockPath, payload, { flag: "wx" });
+            return true;
+        }
+        catch (error) {
+            if (error?.code !== "EEXIST")
+                throw error;
+        }
+        const holder = await readLockPid(lockPath);
+        if (holder !== null && processAlive(holder))
+            return false;
+        try {
+            await rm(lockPath, { force: true });
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+async function releaseLock(lockPath) {
+    try {
+        await rm(lockPath, { force: true });
+    }
+    catch { }
+}
+function classifyFetchError(error) {
+    const name = error && typeof error === "object" && "name" in error
+        ? String(error.name)
+        : "";
+    return name === "TimeoutError" || name === "AbortError"
+        ? "timeout"
+        : "transport";
+}
+async function readBoundedBody(response, maxBytes) {
+    const declared = response.headers.get("content-length");
+    if (declared && Number(declared) > maxBytes) {
+        try {
+            await response.body?.cancel();
+        }
+        catch { }
+        return {
+            ok: false,
+            code: "too_large",
+            message: `Artificial Analysis response exceeds the ${maxBytes} byte limit.`,
+        };
+    }
+    if (!response.body)
+        return "";
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                try {
+                    await reader.cancel();
+                }
+                catch { }
+                return {
+                    ok: false,
+                    code: "too_large",
+                    message: `Artificial Analysis response exceeds the ${maxBytes} byte limit.`,
+                };
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    let size = 0;
+    for (const chunk of chunks)
+        size += chunk.byteLength;
+    const merged = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(merged);
+}
+function httpFailure(status) {
+    let hint = `Artificial Analysis request failed with HTTP ${status}.`;
+    if (status === 401 || status === 403) {
+        hint += " Check that ARTIFICIAL_ANALYSIS_API_KEY is valid.";
+    }
+    else if (status === 429) {
+        hint += " Rate limit exceeded; retry later.";
+    }
+    return { ok: false, code: "http", message: hint, status };
+}
+function metricCoverage(snapshot) {
+    const coverage = {};
+    for (const metric of RECOGNIZED_METRICS) {
+        coverage[metric.key] = snapshot.models.filter((model) => typeof model.evaluations[metric.key] === "number").length;
+    }
+    return coverage;
+}
+// Best-effort read of the previous snapshot hash for unchanged detection.
+// Any failure means "treat as changed", never an update failure.
+async function previousContentHash(targetPath) {
+    try {
+        const raw = await readFile(targetPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return null;
+        const hash = parsed.contentHash;
+        return typeof hash === "string" ? hash : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function updateBenchmarkSnapshot(targetPath, deps = {}) {
+    if (typeof targetPath !== "string" || !isAbsolute(targetPath)) {
+        return {
+            ok: false,
+            code: "invalid_path",
+            message: "Benchmark snapshot path must be an absolute path.",
+        };
+    }
+    const env = deps.env ?? process.env;
+    const apiKey = (deps.apiKey ?? env[AA_API_KEY_ENV] ?? "").trim();
+    if (!apiKey) {
+        return {
+            ok: false,
+            code: "missing_key",
+            message: `Set ${AA_API_KEY_ENV} to refresh Artificial Analysis benchmarks.`,
+        };
+    }
+    const timeoutMs = deps.timeoutMs ?? BENCHMARK_UPDATE_TIMEOUT_MS;
+    const maxBytes = deps.maxBytes ?? BENCHMARK_UPDATE_MAX_BYTES;
+    const now = deps.now ?? (() => new Date().toISOString());
+    const randomId = deps.randomId ?? defaultRandomId;
+    const currentPid = deps.currentPid ?? process.pid;
+    const processAlive = deps.processAlive ?? defaultProcessAlive;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const dir = dirname(targetPath);
+    try {
+        await mkdir(dir, { recursive: true });
+    }
+    catch {
+        return {
+            ok: false,
+            code: "write_failed",
+            message: `Cannot create the benchmark directory for ${targetPath}.`,
+        };
+    }
+    const lockPath = lockPathFor(targetPath);
+    const fetchedAt = now();
+    let locked = false;
+    try {
+        locked = await acquireLock(lockPath, currentPid, processAlive, fetchedAt);
+    }
+    catch {
+        return {
+            ok: false,
+            code: "write_failed",
+            message: `Cannot coordinate the benchmark update for ${targetPath}.`,
+        };
+    }
+    if (!locked) {
+        return {
+            ok: false,
+            code: "busy",
+            message: `Another benchmarks update is already running for ${targetPath}. ` +
+                `If no updater is running, remove ${lockPath} and retry.`,
+        };
+    }
+    const stagePath = join(dir, `${stagePrefixFor(targetPath)}${currentPid}.${randomId()}.tmp`);
+    try {
+        await reapStaleStaging(targetPath);
+        let response;
+        try {
+            response = await fetchImpl(AA_LLM_MODELS_ENDPOINT, {
+                headers: { "x-api-key": apiKey },
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: "error",
+            });
+        }
+        catch (error) {
+            const code = classifyFetchError(error);
+            return {
+                ok: false,
+                code,
+                message: code === "timeout"
+                    ? `Artificial Analysis request timed out after ${timeoutMs} ms.`
+                    : "Artificial Analysis request failed before a response arrived.",
+            };
+        }
+        if (!response.ok)
+            return httpFailure(response.status);
+        const text = await readBoundedBody(response, maxBytes);
+        if (typeof text !== "string")
+            return text;
+        let body;
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            return {
+                ok: false,
+                code: "invalid_response",
+                message: "Artificial Analysis response was not valid JSON.",
+            };
+        }
+        const snapshot = normalizeAAResponse(body, fetchedAt);
+        if ("error" in snapshot) {
+            return { ok: false, code: "invalid_response", message: snapshot.error };
+        }
+        const unchanged = (await previousContentHash(targetPath)) === snapshot.contentHash;
+        const serialized = JSON.stringify(snapshot, null, 2);
+        try {
+            const handle = await open(stagePath, "w");
+            try {
+                await handle.writeFile(serialized, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await rename(stagePath, targetPath);
+        }
+        catch {
+            return {
+                ok: false,
+                code: "write_failed",
+                message: `Cannot publish the benchmark snapshot to ${targetPath}.`,
+            };
+        }
+        return {
+            ok: true,
+            path: targetPath,
+            fetchedAt: snapshot.fetchedAt,
+            modelCount: snapshot.models.length,
+            contentHash: snapshot.contentHash,
+            unchanged,
+            metricCoverage: metricCoverage(snapshot),
+        };
+    }
+    finally {
+        try {
+            await rm(stagePath, { force: true });
+        }
+        catch { }
+        await releaseLock(lockPath);
+    }
+}
+//# sourceMappingURL=benchmarkUpdate.js.map