@danypops/jittor 0.14.0 → 0.16.0

package/src/domain/benchmark.ts

@@ -6,10 +6,10 @@ import {
 	BENCHMARK_MAX_TEXT_CHARACTERS,
 	BENCHMARK_REFRESH_INTERVAL_MS,
 } from "../constants.ts";
-import { METRIC_UNITS, type MetricUnit } from "./metric.ts";
 import type { BenchmarkController } from "../ports/benchmark-controller.ts";
 import type { BenchmarkSource as BenchmarkSourcePort } from "../ports/benchmark-source.ts";
 import type { BenchmarkStore } from "../ports/benchmark-store.ts";
+import { METRIC_UNITS, type MetricUnit } from "./metric.ts";
 
 export type BenchmarkSourceType = "creator" | "marketplace" | "independent" | "operational" | "preference" | "local";
 
@@ -112,7 +112,9 @@ export function normalizeModelIdentity(provider: string, model: string, aliases:
 	const normalizedModel = identityPart(model, "model", true);
 	const version = VERSION_SUFFIX.exec(normalizedModel)?.[1] ?? null;
 	const canonical = `${normalizedProvider}/${normalizedModel}`;
-	const normalizedAliases = [...new Set(aliases.map((alias) => boundedText(alias, "alias", BENCHMARK_IDENTITY_MAX_CHARACTERS).toLowerCase()))]
+	const normalizedAliases = [
+		...new Set(aliases.map((alias) => boundedText(alias, "alias", BENCHMARK_IDENTITY_MAX_CHARACTERS).toLowerCase())),
+	]
 		.filter((alias) => alias !== canonical)
 		.sort();
 	return { provider: normalizedProvider, model: normalizedModel, version, canonical, aliases: normalizedAliases };
@@ -121,9 +123,10 @@ export function normalizeModelIdentity(provider: string, model: string, aliases:
 function validateIdentity(value: unknown): ModelIdentity {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("model identity is required");
 	const input = value as Record<string, unknown>;
-	if (!Array.isArray(input["aliases"]) || !input["aliases"].every((alias) => typeof alias === "string")) throw new Error("model aliases are invalid");
-	const normalized = normalizeModelIdentity(String(input["provider"] ?? ""), String(input["model"] ?? ""), input["aliases"] as string[]);
-	if (input["canonical"] !== normalized.canonical || input["version"] !== normalized.version) throw new Error("model identity is not normalized");
+	if (!Array.isArray(input.aliases) || !input.aliases.every((alias) => typeof alias === "string"))
+		throw new Error("model aliases are invalid");
+	const normalized = normalizeModelIdentity(String(input.provider ?? ""), String(input.model ?? ""), input.aliases as string[]);
+	if (input.canonical !== normalized.canonical || input.version !== normalized.version) throw new Error("model identity is not normalized");
 	return normalized;
 }
 
@@ -136,26 +139,31 @@ function validateTimestamp(value: unknown, name: string, nullable = false): numb
 function validateProvenance(value: unknown): BenchmarkProvenance {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("provenance is required");
 	const input = value as Record<string, unknown>;
-	const sourceId = identityPart(String(input["sourceId"] ?? ""), "source id");
-	if (!SOURCE_TYPES.has(input["sourceType"] as BenchmarkSourceType)) throw new Error("source type is invalid");
+	const sourceId = identityPart(String(input.sourceId ?? ""), "source id");
+	if (!SOURCE_TYPES.has(input.sourceType as BenchmarkSourceType)) throw new Error("source type is invalid");
 	let url: URL;
-	try { url = new URL(boundedText(input["url"], "source URL")); } catch { throw new Error("source URL is invalid"); }
+	try {
+		url = new URL(boundedText(input.url, "source URL"));
+	} catch {
+		throw new Error("source URL is invalid");
+	}
 	if (url.protocol !== "https:") throw new Error("source URL must use HTTPS");
-	const confidence = input["confidence"];
-	if (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) throw new Error("confidence must be between zero and one");
-	const retrievedAt = validateTimestamp(input["retrievedAt"], "retrieval time") as number;
-	const freshUntil = validateTimestamp(input["freshUntil"], "freshness deadline") as number;
+	const confidence = input.confidence;
+	if (typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1)
+		throw new Error("confidence must be between zero and one");
+	const retrievedAt = validateTimestamp(input.retrievedAt, "retrieval time") as number;
+	const freshUntil = validateTimestamp(input.freshUntil, "freshness deadline") as number;
 	if (freshUntil < retrievedAt) throw new Error("freshness deadline precedes retrieval");
 	return {
 		sourceId,
-		sourceType: input["sourceType"] as BenchmarkSourceType,
-		publisher: boundedText(input["publisher"], "publisher"),
+		sourceType: input.sourceType as BenchmarkSourceType,
+		publisher: boundedText(input.publisher, "publisher"),
 		url: url.toString(),
-		revision: boundedText(input["revision"], "revision"),
-		publishedAt: validateTimestamp(input["publishedAt"], "publication time", true),
+		revision: boundedText(input.revision, "revision"),
+		publishedAt: validateTimestamp(input.publishedAt, "publication time", true),
 		retrievedAt,
 		freshUntil,
-		license: boundedText(input["license"], "license"),
+		license: boundedText(input.license, "license"),
 		confidence,
 	};
 }
@@ -170,16 +178,16 @@ function validateMethodology(value: unknown): BenchmarkObservation["methodology"
 export function validateBenchmarkObservation(value: unknown): BenchmarkObservation {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("benchmark observation must be an object");
 	const input = value as Record<string, unknown>;
-	const numericValue = input["value"];
+	const numericValue = input.value;
 	if (typeof numericValue !== "number" || !Number.isFinite(numericValue)) throw new Error("benchmark value must be finite");
-	if (!METRIC_UNITS.includes(input["unit"] as MetricUnit)) throw new Error("benchmark unit is not supported");
+	if (!METRIC_UNITS.includes(input.unit as MetricUnit)) throw new Error("benchmark unit is not supported");
 	return {
-		model: validateIdentity(input["model"]),
-		dimension: identityPart(String(input["dimension"] ?? ""), "dimension"),
+		model: validateIdentity(input.model),
+		dimension: identityPart(String(input.dimension ?? ""), "dimension"),
 		value: numericValue,
-		unit: input["unit"] as MetricUnit,
-		provenance: validateProvenance(input["provenance"]),
-		methodology: validateMethodology(input["methodology"]),
+		unit: input.unit as MetricUnit,
+		provenance: validateProvenance(input.provenance),
+		methodology: validateMethodology(input.methodology),
 	};
 }
 
@@ -188,9 +196,12 @@ function validateSourceSnapshot(value: BenchmarkSourceSnapshot, expectedSourceId
 	if (sourceId !== expectedSourceId) throw new Error("source snapshot identity mismatch");
 	const snapshotId = boundedText(value.snapshotId, "snapshot id", BENCHMARK_IDENTITY_MAX_CHARACTERS);
 	const retrievedAt = validateTimestamp(value.retrievedAt, "retrieval time") as number;
-	if (!Array.isArray(value.observations) || value.observations.length > BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT) throw new Error("source snapshot exceeds the observation limit");
+	if (!Array.isArray(value.observations) || value.observations.length > BENCHMARK_MAX_OBSERVATIONS_PER_SNAPSHOT)
+		throw new Error("source snapshot exceeds the observation limit");
 	const observations = value.observations.map(validateBenchmarkObservation);
-	if (observations.some((observation) => observation.provenance.sourceId !== sourceId || observation.provenance.retrievedAt !== retrievedAt)) {
+	if (
+		observations.some((observation) => observation.provenance.sourceId !== sourceId || observation.provenance.retrievedAt !== retrievedAt)
+	) {
 		throw new Error("source snapshot provenance mismatch");
 	}
 	return { sourceId, snapshotId, retrievedAt, observations };
@@ -223,19 +234,36 @@ export class BenchmarkCatalog implements BenchmarkController {
 
 	async refresh(force = false): Promise<BenchmarkRefreshResult> {
 		const now = this.clock();
-		await Promise.all(this.sources.map(async (source) => {
-			const prior = this.states.get(source.id)!;
-			if (!force && prior.lastAttemptAt !== null && now - prior.lastAttemptAt < this.refreshIntervalMs) return;
-			this.states.set(source.id, { ...prior, lastAttemptAt: now });
-			try {
-				const snapshot = validateSourceSnapshot(await source.fetch(), source.id);
-				const published = this.store.publish(snapshot.sourceId, snapshot.snapshotId, snapshot.observations);
-				this.states.set(source.id, { id: source.id, ok: true, hasEvidence: true, lastAttemptAt: now, lastSuccessAt: published.retrievedAt, observations: published.observations.length });
-			} catch {
-				const evidence = this.store.latest(source.id);
-				this.states.set(source.id, { id: source.id, ok: false, hasEvidence: evidence !== null, lastAttemptAt: now, lastSuccessAt: evidence?.retrievedAt ?? prior.lastSuccessAt, observations: evidence?.observations.length ?? prior.observations, error: "source refresh failed" });
-			}
-		}));
+		await Promise.all(
+			this.sources.map(async (source) => {
+				const prior = this.states.get(source.id)!;
+				if (!force && prior.lastAttemptAt !== null && now - prior.lastAttemptAt < this.refreshIntervalMs) return;
+				this.states.set(source.id, { ...prior, lastAttemptAt: now });
+				try {
+					const snapshot = validateSourceSnapshot(await source.fetch(), source.id);
+					const published = this.store.publish(snapshot.sourceId, snapshot.snapshotId, snapshot.observations);
+					this.states.set(source.id, {
+						id: source.id,
+						ok: true,
+						hasEvidence: true,
+						lastAttemptAt: now,
+						lastSuccessAt: published.retrievedAt,
+						observations: published.observations.length,
+					});
+				} catch {
+					const evidence = this.store.latest(source.id);
+					this.states.set(source.id, {
+						id: source.id,
+						ok: false,
+						hasEvidence: evidence !== null,
+						lastAttemptAt: now,
+						lastSuccessAt: evidence?.retrievedAt ?? prior.lastSuccessAt,
+						observations: evidence?.observations.length ?? prior.observations,
+						error: "source refresh failed",
+					});
+				}
+			}),
+		);
 		return { observedAt: now, sources: this.status().sources };
 	}
 
@@ -251,7 +279,11 @@ export class BenchmarkCatalog implements BenchmarkController {
 		const limit = Math.max(1, Math.min(BENCHMARK_MAX_QUERY_LIMIT, requestedLimit));
 		const model = input.model?.trim().toLowerCase();
 		const dimension = input.dimension?.trim().toLowerCase();
-		const matched = snapshot.observations.filter((observation) => (!model || observation.model.canonical === model || observation.model.aliases.includes(model)) && (!dimension || observation.dimension === dimension));
+		const matched = snapshot.observations.filter(
+			(observation) =>
+				(!model || observation.model.canonical === model || observation.model.aliases.includes(model)) &&
+				(!dimension || observation.dimension === dimension),
+		);
 		const freshUntil = Math.min(...snapshot.observations.map((observation) => observation.provenance.freshUntil));
 		return {
 			...structuredClone(snapshot),

package/src/domain/codex-recovery.ts

@@ -1,8 +1,4 @@
-import {
-	CODEX_ERROR_MESSAGE_LIMIT,
-	CODEX_RETRY_AFTER_MAX_MS,
-	MILLISECONDS_PER_SECOND,
-} from "../constants.ts";
+import { CODEX_ERROR_MESSAGE_LIMIT, CODEX_RETRY_AFTER_MAX_MS, MILLISECONDS_PER_SECOND } from "../constants.ts";
 
 export type CodexFailureKind =
 	| "concurrency"
@@ -57,10 +53,12 @@ export class CodexRecoveryPolicy {
 		private readonly random: () => number = Math.random,
 	) {
 		if (!Number.isFinite(options.baseDelayMs) || options.baseDelayMs < 0) throw new Error("baseDelayMs must be non-negative");
-		if (!Number.isFinite(options.maxDelayMs) || options.maxDelayMs < options.baseDelayMs) throw new Error("maxDelayMs must be at least baseDelayMs");
+		if (!Number.isFinite(options.maxDelayMs) || options.maxDelayMs < options.baseDelayMs)
+			throw new Error("maxDelayMs must be at least baseDelayMs");
 		if (!Number.isInteger(options.maxAttempts) || options.maxAttempts < 1) throw new Error("maxAttempts must be a positive integer");
 		if (!Number.isFinite(options.attemptWindowMs) || options.attemptWindowMs <= 0) throw new Error("attemptWindowMs must be positive");
-		if (!Number.isFinite(options.jitterRatio) || options.jitterRatio < 0 || options.jitterRatio > 1) throw new Error("jitterRatio must be between 0 and 1");
+		if (!Number.isFinite(options.jitterRatio) || options.jitterRatio < 0 || options.jitterRatio > 1)
+			throw new Error("jitterRatio must be between 0 and 1");
 	}
 
 	observeFailure(failure: CodexFailure, now: number): void {
@@ -88,13 +86,15 @@ export class CodexRecoveryPolicy {
 		this.normalizeWindow(now);
 		if (!this.pendingFailure) return { action: "wait", reason: "no transient Codex failure is pending" };
 		if (this.attempts >= this.options.maxAttempts) {
-			return { action: "exhausted", reason: `${this.options.maxAttempts} recovery attempts reached within ${this.options.attemptWindowMs}ms` };
+			return {
+				action: "exhausted",
+				reason: `${this.options.maxAttempts} recovery attempts reached within ${this.options.attemptWindowMs}ms`,
+			};
 		}
-		const base = this.pendingFailure.retryAfterMs
-			?? this.options.baseDelayMs * (2 ** this.attempts);
+		const base = this.pendingFailure.retryAfterMs ?? this.options.baseDelayMs * 2 ** this.attempts;
 		const sample = this.random();
 		const unit = Number.isFinite(sample) ? Math.min(1, Math.max(0, sample)) : 0;
-		const multiplier = 1 + ((unit * 2) - 1) * this.options.jitterRatio;
+		const multiplier = 1 + (unit * 2 - 1) * this.options.jitterRatio;
 		const jittered = Math.max(0, Math.round(base * multiplier));
 		const delayMs = this.pendingFailure.retryAfterMs === undefined ? jittered : Math.max(base, jittered);
 		return {
@@ -135,9 +135,7 @@ export class CodexRecoveryPolicy {
 }
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return typeof value === "object" && value !== null && !Array.isArray(value)
-		? value as Record<string, unknown>
-		: undefined;
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 }
 
 function firstString(...values: unknown[]): string | undefined {
@@ -160,15 +158,15 @@ function matches(value: string, patterns: readonly string[]): boolean {
 
 export function classifyCodexFailure(value: unknown, metadata: CodexFailureMetadata = {}): CodexFailure {
 	const root = asRecord(value);
-	const detail = asRecord(root?.["detail"]);
-	const nestedError = asRecord(root?.["error"]);
-	const code = firstString(detail?.["code"], detail?.["error_code"], nestedError?.["code"], root?.["code"]);
-	const source = firstString(detail?.["source"], nestedError?.["source"], root?.["source"]);
+	const detail = asRecord(root?.detail);
+	const nestedError = asRecord(root?.error);
+	const code = firstString(detail?.code, detail?.error_code, nestedError?.code, root?.code);
+	const source = firstString(detail?.source, nestedError?.source, root?.source);
 	const rawMessage = firstString(
-		detail?.["message"],
-		typeof root?.["error"] === "string" ? root["error"] : undefined,
-		nestedError?.["message"],
-		root?.["message"],
+		detail?.message,
+		typeof root?.error === "string" ? root.error : undefined,
+		nestedError?.message,
+		root?.message,
 		typeof value === "string" ? value : undefined,
 	);
 	const message = rawMessage?.slice(0, CODEX_ERROR_MESSAGE_LIMIT);
@@ -183,16 +181,27 @@ export function classifyCodexFailure(value: unknown, metadata: CodexFailureMetad
 	if (matches(evidence, ["insufficient_quota", "quota exceeded", "out of credits", "billing"])) {
 		return { kind: "quota", transient: false, ...base };
 	}
-	if (metadata.status === 401 || metadata.status === 403 || matches(evidence, ["invalid_api_key", "authentication", "unauthorized", "permission_denied"])) {
+	if (
+		metadata.status === 401 ||
+		metadata.status === 403 ||
+		matches(evidence, ["invalid_api_key", "authentication", "unauthorized", "permission_denied"])
+	) {
 		return { kind: "authentication", transient: false, ...base };
 	}
-	if (matches(evidence, ["invalid_prompt", "invalid_request", "context_length_exceeded"]) || metadata.status === 400 || metadata.status === 422) {
+	if (
+		matches(evidence, ["invalid_prompt", "invalid_request", "context_length_exceeded"]) ||
+		metadata.status === 400 ||
+		metadata.status === 422
+	) {
 		return { kind: "invalid-request", transient: false, ...base };
 	}
 	if (matches(evidence, ["concurrency_limit", "too many concurrent requests", "throttled"])) {
 		return { kind: "concurrency", transient: true, ...base };
 	}
-	if (matches(evidence, ["server_is_overloaded", "slow_down", "service unavailable", "overloaded"]) || (metadata.status !== undefined && metadata.status >= 500 && metadata.status <= 599)) {
+	if (
+		matches(evidence, ["server_is_overloaded", "slow_down", "service unavailable", "overloaded"]) ||
+		(metadata.status !== undefined && metadata.status >= 500 && metadata.status <= 599)
+	) {
 		return { kind: "overload", transient: true, ...base };
 	}
 	if (metadata.status === 429 || matches(evidence, ["rate_limit_exceeded", "rate limit", "too many requests"])) {

package/src/domain/context-hub.ts

@@ -17,8 +17,8 @@ import {
 	CONTEXT_HUB_CONTRIBUTION_MAX_AGE_MS,
 	CONTEXT_HUB_CONTRIBUTION_SCHEMA,
 	CONTEXT_HUB_ITEM_LABEL_MAX_CHARACTERS,
-	CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT,
 	CONTEXT_HUB_MAX_ITEM_DEPTH,
+	CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT,
 	CONTEXT_HUB_PRODUCER_NAME_MAX_CHARACTERS,
 	CONTEXT_HUB_SEGMENT_KEY_MAX_CHARACTERS,
 	CONTEXT_HUB_SEGMENT_LABEL_MAX_CHARACTERS,
@@ -58,12 +58,14 @@ export interface ContextContribution {
 }
 
 function nonEmptyString(value: unknown, name: string, maxLength: number): string {
-	if (typeof value !== "string" || value.length === 0 || value.length > maxLength) throw new Error(`${name} must be a non-empty string of at most ${maxLength} characters`);
+	if (typeof value !== "string" || value.length === 0 || value.length > maxLength)
+		throw new Error(`${name} must be a non-empty string of at most ${maxLength} characters`);
 	return value;
 }
 
 function boundedInteger(value: unknown, name: string): number {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error(`${name} must be a bounded non-negative integer`);
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+		throw new Error(`${name} must be a bounded non-negative integer`);
 	return value;
 }
 
@@ -76,15 +78,16 @@ function validateSegmentItem(value: unknown, depth: number): ContextSegmentItem
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("context segment item must be an object");
 	const input = value as Record<string, unknown>;
 	for (const key of Object.keys(input)) {
-		if (key !== "label" && key !== "estimatedTokens" && key !== "children") throw new Error(`context segment item contains unexpected field: ${key}`);
+		if (key !== "label" && key !== "estimatedTokens" && key !== "children")
+			throw new Error(`context segment item contains unexpected field: ${key}`);
 	}
 	const item: ContextSegmentItem = {
-		label: nonEmptyString(input["label"], "item.label", CONTEXT_HUB_ITEM_LABEL_MAX_CHARACTERS),
-		estimatedTokens: boundedInteger(input["estimatedTokens"], "item.estimatedTokens"),
+		label: nonEmptyString(input.label, "item.label", CONTEXT_HUB_ITEM_LABEL_MAX_CHARACTERS),
+		estimatedTokens: boundedInteger(input.estimatedTokens, "item.estimatedTokens"),
 	};
-	if (input["children"] !== undefined) {
-		if (!Array.isArray(input["children"])) throw new Error("item.children must be an array");
-		item.children = input["children"].map((child) => validateSegmentItem(child, depth + 1));
+	if (input.children !== undefined) {
+		if (!Array.isArray(input.children)) throw new Error("item.children must be an array");
+		item.children = input.children.map((child) => validateSegmentItem(child, depth + 1));
 	}
 	return item;
 }
@@ -98,22 +101,23 @@ export function validateContextSegment(value: unknown): ContextSegment {
 			throw new Error(`context segment contains unexpected field: ${key}`);
 		}
 	}
-	const confidence = input["confidence"];
+	const confidence = input.confidence;
 	if (typeof confidence !== "string" || !CONTEXT_HUB_CONFIDENCE_TIERS.includes(confidence as ContextConfidenceTier)) {
 		throw new Error(`confidence must be one of ${CONTEXT_HUB_CONFIDENCE_TIERS.join(", ")}`);
 	}
-	if (input["unknown"] !== undefined && typeof input["unknown"] !== "boolean") throw new Error("segment.unknown must be a boolean");
+	if (input.unknown !== undefined && typeof input.unknown !== "boolean") throw new Error("segment.unknown must be a boolean");
 	const segment: ContextSegment = {
-		key: nonEmptyString(input["key"], "segment.key", CONTEXT_HUB_SEGMENT_KEY_MAX_CHARACTERS),
-		label: nonEmptyString(input["label"], "segment.label", CONTEXT_HUB_SEGMENT_LABEL_MAX_CHARACTERS),
-		estimatedTokens: boundedInteger(input["estimatedTokens"], "segment.estimatedTokens"),
+		key: nonEmptyString(input.key, "segment.key", CONTEXT_HUB_SEGMENT_KEY_MAX_CHARACTERS),
+		label: nonEmptyString(input.label, "segment.label", CONTEXT_HUB_SEGMENT_LABEL_MAX_CHARACTERS),
+		estimatedTokens: boundedInteger(input.estimatedTokens, "segment.estimatedTokens"),
 		confidence: confidence as ContextConfidenceTier,
-		...(input["unknown"] !== undefined ? { unknown: input["unknown"] as boolean } : {}),
+		...(input.unknown !== undefined ? { unknown: input.unknown as boolean } : {}),
 	};
-	if (input["items"] !== undefined) {
-		if (!Array.isArray(input["items"])) throw new Error("segment.items must be an array");
-		const items = input["items"].map((item) => validateSegmentItem(item, 1));
-		if (countItems(items) > CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT) throw new Error(`segment.items exceeds ${CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT} total items`);
+	if (input.items !== undefined) {
+		if (!Array.isArray(input.items)) throw new Error("segment.items must be an array");
+		const items = input.items.map((item) => validateSegmentItem(item, 1));
+		if (countItems(items) > CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT)
+			throw new Error(`segment.items exceeds ${CONTEXT_HUB_MAX_ITEMS_PER_SEGMENT} total items`);
 		segment.items = items;
 	}
 	return segment;
@@ -125,16 +129,17 @@ const CONTRIBUTION_FIELDS = new Set(["schema", "observedAt", "sequence", "produc
 export function validateContextContribution(value: unknown, now = Date.now()): ContextContribution {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("context contribution must be an object");
 	const input = value as Record<string, unknown>;
-	for (const key of Object.keys(input)) if (!CONTRIBUTION_FIELDS.has(key)) throw new Error(`context contribution contains unexpected field: ${key}`);
-	if (input["schema"] !== CONTEXT_HUB_CONTRIBUTION_SCHEMA) throw new Error("context contribution schema is not supported");
-	const observedAt = boundedInteger(input["observedAt"], "observedAt");
+	for (const key of Object.keys(input))
+		if (!CONTRIBUTION_FIELDS.has(key)) throw new Error(`context contribution contains unexpected field: ${key}`);
+	if (input.schema !== CONTEXT_HUB_CONTRIBUTION_SCHEMA) throw new Error("context contribution schema is not supported");
+	const observedAt = boundedInteger(input.observedAt, "observedAt");
 	if (Math.abs(now - observedAt) > CONTEXT_HUB_CONTRIBUTION_MAX_AGE_MS) throw new Error("context contribution is stale");
 	return {
 		schema: CONTEXT_HUB_CONTRIBUTION_SCHEMA,
 		observedAt,
-		sequence: boundedInteger(input["sequence"], "sequence"),
-		producerName: nonEmptyString(input["producerName"], "producerName", CONTEXT_HUB_PRODUCER_NAME_MAX_CHARACTERS),
-		segment: validateContextSegment(input["segment"]),
+		sequence: boundedInteger(input.sequence, "sequence"),
+		producerName: nonEmptyString(input.producerName, "producerName", CONTEXT_HUB_PRODUCER_NAME_MAX_CHARACTERS),
+		segment: validateContextSegment(input.segment),
 	};
 }
 
@@ -199,7 +204,11 @@ export function computeToolSchemaLedger(tools: readonly ToolLedgerEntry[]): Tool
 	for (const tool of tools) {
 		const source = tool.sourceInfo?.source && tool.sourceInfo.source.length > 0 ? tool.sourceInfo.source : "unknown";
 		const characters = toolCharacters(tool);
-		const usage: ToolLedgerToolUsage = { name: tool.name, characters, estimatedTokens: Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN) };
+		const usage: ToolLedgerToolUsage = {
+			name: tool.name,
+			characters,
+			estimatedTokens: Math.ceil(characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN),
+		};
 		const existing = bySource.get(source);
 		if (existing) existing.push(usage);
 		else bySource.set(source, [usage]);