@danypops/jittor 0.14.0 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/jittor",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Just-in-Time Token Optimizing Router for Pi -- supervised daemon, router policy, and CLI",
   "type": "module",
   "main": "./src/index.ts",
@@ -16,8 +16,9 @@
     "service:install": "bun src/cli.ts service install"
   },
   "dependencies": {
-    "@danypops/vehicle-server": "^0.3.1",
-    "@danypops/vehicle-client": "^0.1.1",
+    "@danypops/vehicle-core": "^0.10.0",
+    "@danypops/vehicle-server": "^0.13.0",
+    "@danypops/vehicle-client": "^0.5.1",
     "google-auth-library": "^10.9.0"
   },
   "devDependencies": {

package/src/adapters/artificial-analysis-direct-source.ts

@@ -1,5 +1,10 @@
 import { BENCHMARK_MAX_MODELS_PER_SOURCE, BENCHMARK_REFRESH_INTERVAL_MS, BENCHMARK_SOURCE_MAX_RESPONSE_BYTES } from "../constants.ts";
-import { normalizeModelIdentity, validateBenchmarkObservation, type BenchmarkObservation, type BenchmarkSourceSnapshot } from "../domain/benchmark.ts";
+import {
+	type BenchmarkObservation,
+	type BenchmarkSourceSnapshot,
+	normalizeModelIdentity,
+	validateBenchmarkObservation,
+} from "../domain/benchmark.ts";
 import type { BenchmarkSource } from "../ports/benchmark-source.ts";
 import { contractRecord } from "../providers/openrouter-contracts.ts";
 
@@ -36,17 +41,25 @@ export class ArtificialAnalysisDirectSource implements BenchmarkSource {
 		const response = await this.transport(new Request(ENDPOINT, { headers: { "x-api-key": this.apiKey } }));
 		if (!response.ok) throw new Error(`Artificial Analysis benchmarks failed with HTTP ${response.status}`);
 		const text = await response.text();
-		if (new TextEncoder().encode(text).byteLength > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES) throw new Error("Artificial Analysis benchmark response exceeds the size limit");
+		if (new TextEncoder().encode(text).byteLength > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES)
+			throw new Error("Artificial Analysis benchmark response exceeds the size limit");
 		let payload: unknown;
-		try { payload = JSON.parse(text); } catch { throw new Error("Artificial Analysis benchmark response is not valid JSON"); }
+		try {
+			payload = JSON.parse(text);
+		} catch {
+			throw new Error("Artificial Analysis benchmark response is not valid JSON");
+		}
 		const root = contractRecord(payload, "benchmark response");
-		if (!Array.isArray(root["data"]) || root["data"].length > BENCHMARK_MAX_MODELS_PER_SOURCE) throw new Error("Artificial Analysis benchmark result count is invalid");
+		if (!Array.isArray(root.data) || root.data.length > BENCHMARK_MAX_MODELS_PER_SOURCE)
+			throw new Error("Artificial Analysis benchmark result count is invalid");
 		const revision = String(retrievedAt);
-		const observations = root["data"].flatMap((value): BenchmarkObservation[] => {
+		const observations = root.data.flatMap((value): BenchmarkObservation[] => {
 			const row = contractRecord(value, "benchmark row");
-			const creator = contractRecord(row["model_creator"], "model creator");
-			const evaluations = contractRecord(row["evaluations"], "evaluations");
-			const identity = normalizeModelIdentity(requiredText(creator["slug"], "creator slug"), requiredText(row["slug"], "model slug"), [`artificial-analysis/${requiredText(row["id"], "model id")}`]);
+			const creator = contractRecord(row.model_creator, "model creator");
+			const evaluations = contractRecord(row.evaluations, "evaluations");
+			const identity = normalizeModelIdentity(requiredText(creator.slug, "creator slug"), requiredText(row.slug, "model slug"), [
+				`artificial-analysis/${requiredText(row.id, "model id")}`,
+			]);
 			const provenance = {
 				sourceId: SOURCE_ID,
 				sourceType: "creator" as const,
@@ -64,14 +77,32 @@ export class ArtificialAnalysisDirectSource implements BenchmarkSource {
 			const index = (field: string, dimension: string): void => {
 				const raw = evaluations[field];
 				if (raw === undefined || raw === null) return;
-				observations.push(validateBenchmarkObservation({ model: identity, dimension, value: requiredNumber(raw, field), unit: "ratio", provenance, methodology }));
+				observations.push(
+					validateBenchmarkObservation({
+						model: identity,
+						dimension,
+						value: requiredNumber(raw, field),
+						unit: "ratio",
+						provenance,
+						methodology,
+					}),
+				);
 			};
 			index("artificial_analysis_coding_index", "quality-coding");
 			index("artificial_analysis_intelligence_index", "quality-general");
 			index("artificial_analysis_math_index", "quality-math");
-			const ttft = row["median_time_to_first_token_seconds"];
+			const ttft = row.median_time_to_first_token_seconds;
 			if (typeof ttft === "number" && Number.isFinite(ttft)) {
-				observations.push(validateBenchmarkObservation({ model: identity, dimension: "latency", value: ttft * 1_000, unit: "milliseconds", provenance, methodology }));
+				observations.push(
+					validateBenchmarkObservation({
+						model: identity,
+						dimension: "latency",
+						value: ttft * 1_000,
+						unit: "milliseconds",
+						provenance,
+						methodology,
+					}),
+				);
 			}
 			return observations;
 		});

package/src/adapters/lmarena-hf-source.ts

@@ -1,5 +1,10 @@
 import { BENCHMARK_MAX_MODELS_PER_SOURCE, BENCHMARK_REFRESH_INTERVAL_MS, BENCHMARK_SOURCE_MAX_RESPONSE_BYTES } from "../constants.ts";
-import { normalizeModelIdentity, validateBenchmarkObservation, type BenchmarkObservation, type BenchmarkSourceSnapshot } from "../domain/benchmark.ts";
+import {
+	type BenchmarkObservation,
+	type BenchmarkSourceSnapshot,
+	normalizeModelIdentity,
+	validateBenchmarkObservation,
+} from "../domain/benchmark.ts";
 import type { BenchmarkSource } from "../ports/benchmark-source.ts";
 import { contractRecord } from "../providers/openrouter-contracts.ts";
 
@@ -46,7 +51,10 @@ function requiredNumber(value: unknown, name: string): number {
  */
 function bestEffortIdentity(organization: string, displayName: string): { provider: string; model: string; aliases: string[] } {
 	const base = displayName.replace(THINKING_SUFFIX, "").trim();
-	const slug = base.toLowerCase().replace(/[^a-z0-9.]+/g, "-").replace(/^-+|-+$/g, "");
+	const slug = base
+		.toLowerCase()
+		.replace(/[^a-z0-9.]+/g, "-")
+		.replace(/^-+|-+$/g, "");
 	return { provider: organization, model: slug, aliases: [displayName.toLowerCase()] };
 }
 
@@ -63,32 +71,44 @@ export class LmArenaHfSource implements BenchmarkSource {
 		if (!Number.isSafeInteger(retrievedAt) || retrievedAt <= 0) throw new Error("benchmark retrieval time is invalid");
 		const perArena = await Promise.all(ARENAS.map((arena) => this.fetchArena(arena, retrievedAt)));
 		const observations = perArena.flatMap((page) => page.observations).slice(0, BENCHMARK_MAX_MODELS_PER_SOURCE * ARENAS.length);
-		const asOf = perArena.map((page) => page.asOf).sort().at(-1) ?? "unknown";
+		const asOf =
+			perArena
+				.map((page) => page.asOf)
+				.sort()
+				.at(-1) ?? "unknown";
 		return { sourceId: this.id, snapshotId: `${this.id}:${asOf}`, retrievedAt, observations };
 	}
 
-	private async fetchArena(arena: { config: string; dimension: string; unit: "ratio" }, retrievedAt: number): Promise<{ asOf: string; observations: BenchmarkObservation[] }> {
+	private async fetchArena(
+		arena: { config: string; dimension: string; unit: "ratio" },
+		retrievedAt: number,
+	): Promise<{ asOf: string; observations: BenchmarkObservation[] }> {
 		const url = `${BASE_URL}?dataset=lmarena-ai%2Fleaderboard-dataset&config=${arena.config}&split=latest&length=${HF_ROWS_PER_PAGE}`;
 		const response = await this.transport(new Request(url));
 		if (!response.ok) throw new Error(`LMArena benchmark fetch failed with HTTP ${response.status}`);
 		const text = await response.text();
-		if (new TextEncoder().encode(text).byteLength > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES) throw new Error("LMArena benchmark response exceeds the size limit");
+		if (new TextEncoder().encode(text).byteLength > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES)
+			throw new Error("LMArena benchmark response exceeds the size limit");
 		let payload: unknown;
-		try { payload = JSON.parse(text); } catch { throw new Error("LMArena benchmark response is not valid JSON"); }
+		try {
+			payload = JSON.parse(text);
+		} catch {
+			throw new Error("LMArena benchmark response is not valid JSON");
+		}
 		const root = contractRecord(payload, "benchmark response");
-		if (!Array.isArray(root["rows"]) || root["rows"].length > HF_ROWS_PER_PAGE) throw new Error("LMArena benchmark row count is invalid");
+		if (!Array.isArray(root.rows) || root.rows.length > HF_ROWS_PER_PAGE) throw new Error("LMArena benchmark row count is invalid");
 		let asOf = "";
-		const observations = root["rows"].flatMap((entry): BenchmarkObservation[] => {
+		const observations = root.rows.flatMap((entry): BenchmarkObservation[] => {
 			const wrapper = contractRecord(entry, "benchmark row wrapper");
-			const row = contractRecord(wrapper["row"], "benchmark row");
-			const publishDate = requiredText(row["leaderboard_publish_date"], "publish date");
+			const row = contractRecord(wrapper.row, "benchmark row");
+			const publishDate = requiredText(row.leaderboard_publish_date, "publish date");
 			if (publishDate > asOf) asOf = publishDate;
 			// Skip finer per-category splits, if any exist for this config -- out of scope for now.
-			if (requiredText(row["category"], "category") !== "overall") return [];
-			const scoreValue = row["rating"] ?? row["score"];
+			if (requiredText(row.category, "category") !== "overall") return [];
+			const scoreValue = row.rating ?? row.score;
 			const value = requiredNumber(scoreValue, "score");
-			const organization = requiredText(row["organization"], "organization");
-			const displayName = requiredText(row["model_name"], "model name");
+			const organization = requiredText(row.organization, "organization");
+			const displayName = requiredText(row.model_name, "model name");
 			const guessed = bestEffortIdentity(organization, displayName);
 			const identity = normalizeModelIdentity(guessed.provider, guessed.model, guessed.aliases);
 			const provenance = {
@@ -104,7 +124,9 @@ export class LmArenaHfSource implements BenchmarkSource {
 				confidence: 0.6,
 			};
 			const methodology = { basis: "LMArena human-preference battles", arena: arena.config, displayName, publishDate };
-			return [validateBenchmarkObservation({ model: identity, dimension: arena.dimension, value, unit: arena.unit, provenance, methodology })];
+			return [
+				validateBenchmarkObservation({ model: identity, dimension: arena.dimension, value, unit: arena.unit, provenance, methodology }),
+			];
 		});
 		return { asOf, observations };
 	}

package/src/adapters/metric-benchmark-store.ts

@@ -1,12 +1,5 @@
-import {
-	BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT,
-	BENCHMARK_STORE_QUERY_LIMIT,
-} from "../constants.ts";
-import {
-	validateBenchmarkObservation,
-	type BenchmarkObservation,
-	type BenchmarkSnapshot,
-} from "../domain/benchmark.ts";
+import { BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT, BENCHMARK_STORE_QUERY_LIMIT } from "../constants.ts";
+import { type BenchmarkObservation, type BenchmarkSnapshot, validateBenchmarkObservation } from "../domain/benchmark.ts";
 import type { StoredMetricObservation } from "../domain/metric.ts";
 import type { BenchmarkStore } from "../ports/benchmark-store.ts";
 import type { MetricStore } from "../ports/metric-store.ts";
@@ -29,12 +22,12 @@ function observationAttributes(snapshotId: string, observation: BenchmarkObserva
 
 function decodeObservation(row: StoredMetricObservation): BenchmarkObservation {
 	return validateBenchmarkObservation({
-		model: row.attributes["model"],
+		model: row.attributes.model,
 		dimension: row.metric,
 		value: row.value,
 		unit: row.unit,
-		provenance: row.attributes["provenance"],
-		methodology: row.attributes["methodology"],
+		provenance: row.attributes.provenance,
+		methodology: row.attributes.methodology,
 	});
 }
 
@@ -47,7 +40,10 @@ export class MetricBenchmarkStore implements BenchmarkStore {
 		const existing = this.latest(sourceId);
 		if (existing?.snapshotId === snapshotId) return existing;
 		const retrievedAt = observations[0]?.provenance.retrievedAt;
-		if (retrievedAt === undefined || observations.some((observation) => observation.provenance.sourceId !== sourceId || observation.provenance.retrievedAt !== retrievedAt)) {
+		if (
+			retrievedAt === undefined ||
+			observations.some((observation) => observation.provenance.sourceId !== sourceId || observation.provenance.retrievedAt !== retrievedAt)
+		) {
 			throw new Error("benchmark snapshot provenance mismatch");
 		}
 		for (const observation of observations) {
@@ -74,15 +70,30 @@ export class MetricBenchmarkStore implements BenchmarkStore {
 	}
 
 	latest(sourceId: string): BenchmarkSnapshot | null {
-		const marker = this.metrics.query({ source: metricSource(sourceId), scope: SNAPSHOT_SCOPE, metric: COMPLETE_METRIC, order: "desc", limit: 1 })[0];
+		const marker = this.metrics.query({
+			source: metricSource(sourceId),
+			scope: SNAPSHOT_SCOPE,
+			metric: COMPLETE_METRIC,
+			order: "desc",
+			limit: 1,
+		})[0];
 		if (!marker) return null;
-		const rows = this.metrics.query({ source: metricSource(sourceId), until: marker.observedAt, order: "desc", limit: BENCHMARK_STORE_QUERY_LIMIT });
+		const rows = this.metrics.query({
+			source: metricSource(sourceId),
+			until: marker.observedAt,
+			order: "desc",
+			limit: BENCHMARK_STORE_QUERY_LIMIT,
+		});
 		const markerIndex = rows.findIndex((row) => row.id === marker.id);
 		if (markerIndex < 0) return null;
-		const snapshotId = marker.attributes["snapshotId"];
+		const snapshotId = marker.attributes.snapshotId;
 		const expectedCount = marker.value;
-		if (typeof snapshotId !== "string" || typeof expectedCount !== "number" || !Number.isSafeInteger(expectedCount) || expectedCount < 0) return null;
-		const matching = rows.slice(markerIndex + 1).filter((row) => row.attributes["snapshotId"] === snapshotId).slice(0, expectedCount);
+		if (typeof snapshotId !== "string" || typeof expectedCount !== "number" || !Number.isSafeInteger(expectedCount) || expectedCount < 0)
+			return null;
+		const matching = rows
+			.slice(markerIndex + 1)
+			.filter((row) => row.attributes.snapshotId === snapshotId)
+			.slice(0, expectedCount);
 		if (matching.length !== expectedCount) return null;
 		try {
 			return {

package/src/adapters/openrouter-benchmark-source.ts

@@ -4,9 +4,14 @@ import {
 	BENCHMARK_SOURCE_MAX_RESPONSE_BYTES,
 	BENCHMARK_SOURCE_MAX_TOTAL_RESPONSE_BYTES,
 } from "../constants.ts";
-import { normalizeModelIdentity, validateBenchmarkObservation, type BenchmarkObservation, type BenchmarkSourceSnapshot } from "../domain/benchmark.ts";
+import {
+	type BenchmarkObservation,
+	type BenchmarkSourceSnapshot,
+	normalizeModelIdentity,
+	validateBenchmarkObservation,
+} from "../domain/benchmark.ts";
 import type { BenchmarkSource } from "../ports/benchmark-source.ts";
-import { contractRecord, parseOpenRouterModels, type OpenRouterModel } from "../providers/openrouter-contracts.ts";
+import { contractRecord, type OpenRouterModel, parseOpenRouterModels } from "../providers/openrouter-contracts.ts";
 
 const OPENROUTER_MODELS_BASE_URL = "https://openrouter.ai/api/v1/models";
 const OPENROUTER_MODELS_URL = `${OPENROUTER_MODELS_BASE_URL}?limit=${BENCHMARK_MAX_MODELS_PER_SOURCE}`;
@@ -43,23 +48,68 @@ function provenance(retrievedAt: number, revision: string, url: string, confiden
 function modelObservations(model: OpenRouterModel, retrievedAt: number, revision: string): BenchmarkObservation[] {
 	const common = { model: identity(model), provenance: provenance(retrievedAt, revision, OPENROUTER_MODELS_URL, 0.9) };
 	return [
-		validateBenchmarkObservation({ ...common, dimension: "context-window", value: model.contextLength, unit: "tokens", methodology: { basis: "OpenRouter model context_length" } }),
-		...(model.maxCompletionTokens === null ? [] : [validateBenchmarkObservation({ ...common, dimension: "max-output", value: model.maxCompletionTokens, unit: "tokens", methodology: { basis: "OpenRouter top_provider max_completion_tokens" } })]),
-		validateBenchmarkObservation({ ...common, dimension: "price-input", value: model.pricing.prompt, unit: "usd", methodology: { basis: "USD per input token" } }),
-		validateBenchmarkObservation({ ...common, dimension: "price-output", value: model.pricing.completion, unit: "usd", methodology: { basis: "USD per output token" } }),
-		validateBenchmarkObservation({ ...common, dimension: "parameter-count", value: model.supportedParameters.length, unit: "count", methodology: { basis: "OpenRouter supported_parameters", parameters: [...model.supportedParameters].sort() } }),
+		validateBenchmarkObservation({
+			...common,
+			dimension: "context-window",
+			value: model.contextLength,
+			unit: "tokens",
+			methodology: { basis: "OpenRouter model context_length" },
+		}),
+		...(model.maxCompletionTokens === null
+			? []
+			: [
+					validateBenchmarkObservation({
+						...common,
+						dimension: "max-output",
+						value: model.maxCompletionTokens,
+						unit: "tokens",
+						methodology: { basis: "OpenRouter top_provider max_completion_tokens" },
+					}),
+				]),
+		validateBenchmarkObservation({
+			...common,
+			dimension: "price-input",
+			value: model.pricing.prompt,
+			unit: "usd",
+			methodology: { basis: "USD per input token" },
+		}),
+		validateBenchmarkObservation({
+			...common,
+			dimension: "price-output",
+			value: model.pricing.completion,
+			unit: "usd",
+			methodology: { basis: "USD per output token" },
+		}),
+		validateBenchmarkObservation({
+			...common,
+			dimension: "parameter-count",
+			value: model.supportedParameters.length,
+			unit: "count",
+			methodology: { basis: "OpenRouter supported_parameters", parameters: [...model.supportedParameters].sort() },
+		}),
 	];
 }
 
-function rankObservations(models: OpenRouterModel[], dimension: "latency-rank" | "throughput-rank", retrievedAt: number, revision: string, url: string): BenchmarkObservation[] {
-	return models.map((model, index) => validateBenchmarkObservation({
-		model: identity(model),
-		dimension,
-		value: index + 1,
-		unit: "count",
-		provenance: provenance(retrievedAt, revision, url, 0.7),
-		methodology: { basis: dimension === "latency-rank" ? "OpenRouter p50 TTFT server-side ordering" : "OpenRouter p50 throughput server-side ordering", rank: index + 1 },
-	}));
+function rankObservations(
+	models: OpenRouterModel[],
+	dimension: "latency-rank" | "throughput-rank",
+	retrievedAt: number,
+	revision: string,
+	url: string,
+): BenchmarkObservation[] {
+	return models.map((model, index) =>
+		validateBenchmarkObservation({
+			model: identity(model),
+			dimension,
+			value: index + 1,
+			unit: "count",
+			provenance: provenance(retrievedAt, revision, url, 0.7),
+			methodology: {
+				basis: dimension === "latency-rank" ? "OpenRouter p50 TTFT server-side ordering" : "OpenRouter p50 throughput server-side ordering",
+				rank: index + 1,
+			},
+		}),
+	);
 }
 
 interface ModelResponse {
@@ -83,9 +133,14 @@ export class OpenRouterBenchmarkSource implements BenchmarkSource {
 		const bytes = new TextEncoder().encode(text).byteLength;
 		if (bytes > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES) throw new Error("OpenRouter models response exceeds the size limit");
 		let payload: unknown;
-		try { payload = JSON.parse(text); } catch { throw new Error("OpenRouter models response is not valid JSON"); }
+		try {
+			payload = JSON.parse(text);
+		} catch {
+			throw new Error("OpenRouter models response is not valid JSON");
+		}
 		const root = contractRecord(payload, "models response");
-		if (!Array.isArray(root["data"]) || root["data"].length === 0 || root["data"].length > BENCHMARK_MAX_MODELS_PER_SOURCE) throw new Error("OpenRouter models response exceeds the model limit");
+		if (!Array.isArray(root.data) || root.data.length === 0 || root.data.length > BENCHMARK_MAX_MODELS_PER_SOURCE)
+			throw new Error("OpenRouter models response exceeds the model limit");
 		return { models: parseOpenRouterModels(payload), etag: response.headers.get("etag")?.slice(0, 120) ?? null, bytes };
 	}
 
@@ -95,7 +150,8 @@ export class OpenRouterBenchmarkSource implements BenchmarkSource {
 			this.readModels(OPENROUTER_LATENCY_URL),
 			this.readModels(OPENROUTER_THROUGHPUT_URL),
 		]);
-		if (catalog.bytes + latency.bytes + throughput.bytes > BENCHMARK_SOURCE_MAX_TOTAL_RESPONSE_BYTES) throw new Error("OpenRouter model evidence exceeds the total size limit");
+		if (catalog.bytes + latency.bytes + throughput.bytes > BENCHMARK_SOURCE_MAX_TOTAL_RESPONSE_BYTES)
+			throw new Error("OpenRouter model evidence exceeds the total size limit");
 		const retrievedAt = this.clock();
 		if (!Number.isSafeInteger(retrievedAt) || retrievedAt <= 0) throw new Error("benchmark retrieval time is invalid");
 		const revision = catalog.etag || latency.etag || throughput.etag || `retrieved:${retrievedAt}`;

package/src/adapters/openrouter-design-arena-source.ts

@@ -1,9 +1,10 @@
+import { BENCHMARK_MAX_MODELS_PER_SOURCE, BENCHMARK_REFRESH_INTERVAL_MS, BENCHMARK_SOURCE_MAX_RESPONSE_BYTES } from "../constants.ts";
 import {
-	BENCHMARK_MAX_MODELS_PER_SOURCE,
-	BENCHMARK_REFRESH_INTERVAL_MS,
-	BENCHMARK_SOURCE_MAX_RESPONSE_BYTES,
-} from "../constants.ts";
-import { normalizeModelIdentity, validateBenchmarkObservation, type BenchmarkObservation, type BenchmarkSourceSnapshot } from "../domain/benchmark.ts";
+	type BenchmarkObservation,
+	type BenchmarkSourceSnapshot,
+	normalizeModelIdentity,
+	validateBenchmarkObservation,
+} from "../domain/benchmark.ts";
 import type { BenchmarkSource } from "../ports/benchmark-source.ts";
 import { contractRecord } from "../providers/openrouter-contracts.ts";
 import type { OpenRouterBenchmarkTransport } from "./openrouter-benchmark-source.ts";
@@ -22,7 +23,8 @@ const BASE_URL = `https://openrouter.ai/api/v1/benchmarks?source=design-arena&ma
 const RELEVANT_CATEGORIES = ["codecategories", "website", "uicomponent", "dataviz", "svg"] as const;
 
 function requiredText(value: unknown, name: string): string {
-	if (typeof value !== "string" || value.length === 0 || value.length > 500) throw new Error(`OpenRouter Design Arena benchmark ${name} schema changed`);
+	if (typeof value !== "string" || value.length === 0 || value.length > 500)
+		throw new Error(`OpenRouter Design Arena benchmark ${name} schema changed`);
 	return value;
 }
 
@@ -62,24 +64,32 @@ export class OpenRouterDesignArenaSource implements BenchmarkSource {
 		const response = await this.transport(new Request(url, { headers: { authorization: `Bearer ${this.apiKey}` } }));
 		if (!response.ok) throw new Error(`OpenRouter Design Arena benchmarks failed with HTTP ${response.status}`);
 		const text = await response.text();
-		if (new TextEncoder().encode(text).byteLength > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES) throw new Error("OpenRouter Design Arena benchmark response exceeds the size limit");
+		if (new TextEncoder().encode(text).byteLength > BENCHMARK_SOURCE_MAX_RESPONSE_BYTES)
+			throw new Error("OpenRouter Design Arena benchmark response exceeds the size limit");
 		let payload: unknown;
-		try { payload = JSON.parse(text); } catch { throw new Error("OpenRouter Design Arena benchmark response is not valid JSON"); }
+		try {
+			payload = JSON.parse(text);
+		} catch {
+			throw new Error("OpenRouter Design Arena benchmark response is not valid JSON");
+		}
 		const root = contractRecord(payload, "benchmark response");
-		const meta = contractRecord(root["meta"], "benchmark metadata");
-		if (!Array.isArray(root["data"]) || root["data"].length > BENCHMARK_MAX_MODELS_PER_SOURCE) throw new Error("OpenRouter Design Arena benchmark result count is invalid");
-		if (requiredText(meta["source"], "source") !== "design-arena") throw new Error("OpenRouter Design Arena benchmark source schema changed");
-		const asOf = requiredText(meta["as_of"], "as-of date");
+		const meta = contractRecord(root.meta, "benchmark metadata");
+		if (!Array.isArray(root.data) || root.data.length > BENCHMARK_MAX_MODELS_PER_SOURCE)
+			throw new Error("OpenRouter Design Arena benchmark result count is invalid");
+		if (requiredText(meta.source, "source") !== "design-arena") throw new Error("OpenRouter Design Arena benchmark source schema changed");
+		const asOf = requiredText(meta.as_of, "as-of date");
 		const publishedAt = Date.parse(asOf);
-		if (!Number.isSafeInteger(publishedAt) || publishedAt <= 0) throw new Error("OpenRouter Design Arena benchmark publication date schema changed");
+		if (!Number.isSafeInteger(publishedAt) || publishedAt <= 0)
+			throw new Error("OpenRouter Design Arena benchmark publication date schema changed");
 		const revision = `${category}:${asOf}`;
-		const observations = root["data"].flatMap((value): BenchmarkObservation[] => {
+		const observations = root.data.flatMap((value): BenchmarkObservation[] => {
 			const row = contractRecord(value, "benchmark row");
-			if (requiredText(row["source"], "row source") !== "design-arena") throw new Error("OpenRouter Design Arena benchmark row source schema changed");
+			if (requiredText(row.source, "row source") !== "design-arena")
+				throw new Error("OpenRouter Design Arena benchmark row source schema changed");
 			// A null open_router_id means the model isn't reachable through OpenRouter at all
 			// (proprietary platform, image/video generator, deprecated model) -- not evidence
 			// Jittor can ever route against, so the row is skipped rather than rejected.
-			const openRouterId = row["open_router_id"];
+			const openRouterId = row.open_router_id;
 			if (openRouterId === null) return [];
 			const { provider, model } = identityFromOpenRouterId(requiredText(openRouterId, "open_router_id"));
 			const identity = normalizeModelIdentity(provider, model, [`openrouter/${provider}/${model}`]);
@@ -96,9 +106,16 @@ export class OpenRouterDesignArenaSource implements BenchmarkSource {
 				confidence: 0.7,
 			};
 			const methodology = { basis: "Design Arena Elo rating via OpenRouter", category, asOf };
-			return [validateBenchmarkObservation({
-				model: identity, dimension: "quality-design", value: requiredNumber(row["elo"], "elo rating"), unit: "elo", provenance, methodology,
-			})];
+			return [
+				validateBenchmarkObservation({
+					model: identity,
+					dimension: "quality-design",
+					value: requiredNumber(row.elo, "elo rating"),
+					unit: "elo",
+					provenance,
+					methodology,
+				}),
+			];
 		});
 		return { revision, observations };
 	}

package/src/adapters/sqlite-metric-store.ts

@@ -40,22 +40,26 @@ export class SQLiteMetricStore implements MetricStore {
 
 	recordBatch(inputs: MetricObservation[]): StoredMetricObservation[] {
 		const observations = inputs.map((input) => validateMetricObservation(input));
-		return this.db.transaction((rows: typeof observations) => rows.map((observation) => this.get(Number(this.insert(observation).lastInsertRowid))))(observations);
+		return this.db.transaction((rows: typeof observations) =>
+			rows.map((observation) => this.get(Number(this.insert(observation).lastInsertRowid))),
+		)(observations);
 	}
 
 	private insert(observation: MetricObservation): { lastInsertRowid: number | bigint } {
-		return this.db.query(`
+		return this.db
+			.query(`
 			INSERT INTO metric_observations (source, scope, metric, value, unit, observed_at, attributes)
 			VALUES (?, ?, ?, ?, ?, ?, ?)
-		`).run(
-			observation.source,
-			observation.scope,
-			observation.metric,
-			observation.value,
-			observation.unit,
-			observation.observedAt,
-			JSON.stringify(observation.attributes ?? {}),
-		);
+		`)
+			.run(
+				observation.source,
+				observation.scope,
+				observation.metric,
+				observation.value,
+				observation.unit,
+				observation.observedAt,
+				JSON.stringify(observation.attributes ?? {}),
+			);
 	}
 
 	query(filter: MetricQuery = {}): StoredMetricObservation[] {
@@ -69,30 +73,40 @@ export class SQLiteMetricStore implements MetricStore {
 		addEquals("source", filter.source);
 		addEquals("scope", filter.scope);
 		addEquals("metric", filter.metric);
-		if (filter.since !== undefined) { conditions.push("observed_at >= ?"); parameters.push(filter.since); }
-		if (filter.until !== undefined) { conditions.push("observed_at <= ?"); parameters.push(filter.until); }
+		if (filter.since !== undefined) {
+			conditions.push("observed_at >= ?");
+			parameters.push(filter.since);
+		}
+		if (filter.until !== undefined) {
+			conditions.push("observed_at <= ?");
+			parameters.push(filter.until);
+		}
 		const requestedLimit = Number.isFinite(filter.limit) ? Math.floor(filter.limit!) : DEFAULT_QUERY_LIMIT;
 		const limit = Math.max(1, Math.min(MAX_QUERY_LIMIT, requestedLimit));
 		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
 		const order = filter.order === "desc" ? "DESC" : "ASC";
-		const rows = this.db.query(`
+		const rows = this.db
+			.query(`
 			SELECT id, source, scope, metric, value, unit, observed_at, attributes
 			FROM metric_observations
 			${where}
 			ORDER BY observed_at ${order}, id ${order}
 			LIMIT ${limit}
-		`).all(...parameters) as MetricRow[];
+		`)
+			.all(...parameters) as MetricRow[];
 		return rows.map(fromRow);
 	}
 
 	distinctScopes(filter: DistinctScopesFilter): string[] {
 		const limit = Math.max(1, Math.min(MAX_QUERY_LIMIT, Math.floor(filter.limit)));
-		const rows = this.db.query(`
+		const rows = this.db
+			.query(`
 			SELECT DISTINCT scope FROM metric_observations
 			WHERE source = ? AND observed_at >= ? AND observed_at <= ?
 			ORDER BY scope ASC
 			LIMIT ?
-		`).all(filter.source, filter.since, filter.until, limit) as Array<{ scope: string }>;
+		`)
+			.all(filter.source, filter.since, filter.until, limit) as Array<{ scope: string }>;
 		return rows.map((row) => row.scope);
 	}
 
@@ -104,7 +118,8 @@ export class SQLiteMetricStore implements MetricStore {
 		// MIN(a, b) is SQLite's scalar two-argument form (smallest of the arguments), mirroring
 		// usageBucketIndex's own `Math.min(bucketCount - 1, Math.floor(...))` clamp exactly, so a bucket
 		// this returns always matches the same-indexed bucket the client-side window renders.
-		const rows = this.db.query(`
+		const rows = this.db
+			.query(`
 			SELECT scope, metric,
 				MIN(CAST((observed_at - ?) AS REAL) / ?, ? - 1) AS bucket_index_raw,
 				SUM(value) AS sum
@@ -112,11 +127,17 @@ export class SQLiteMetricStore implements MetricStore {
 			WHERE source = ? AND observed_at >= ? AND observed_at <= ? AND value >= 0 AND scope IN (${scopePlaceholders})
 			GROUP BY scope, metric, CAST(bucket_index_raw AS INTEGER)
 			LIMIT ?
-		`).all(
-			filter.since, filter.bucketSizeMs, filter.bucketCount,
-			filter.source, filter.since, filter.until, ...filter.scopes,
-			USAGE_AGGREGATE_MAX_ROWS,
-		) as Array<{ scope: string; metric: string; bucket_index_raw: number; sum: number }>;
+		`)
+			.all(
+				filter.since,
+				filter.bucketSizeMs,
+				filter.bucketCount,
+				filter.source,
+				filter.since,
+				filter.until,
+				...filter.scopes,
+				USAGE_AGGREGATE_MAX_ROWS,
+			) as Array<{ scope: string; metric: string; bucket_index_raw: number; sum: number }>;
 		return rows.map((row) => ({
 			scope: row.scope,
 			metric: row.metric,
@@ -139,10 +160,12 @@ export class SQLiteMetricStore implements MetricStore {
 	}
 
 	private get(id: number): StoredMetricObservation {
-		const row = this.db.query(`
+		const row = this.db
+			.query(`
 			SELECT id, source, scope, metric, value, unit, observed_at, attributes
 			FROM metric_observations WHERE id = ?
-		`).get(id) as MetricRow | null;
+		`)
+			.get(id) as MetricRow | null;
 		if (!row) throw new Error(`metric observation ${id} was not persisted`);
 		return fromRow(row);
 	}