niceeval 0.15.1-canary.76 → 0.16.1

package/dist/inspection/public.mjs

@@ -501,7 +501,8 @@ var AssertionCoverageSchema = Schema.Union([
 			"sampled",
 			"truncated",
 			"redacted",
-			"provider-limited"
+			"provider-limited",
+			"capacity-limited"
 		])
 	}),
 	Schema.Struct({
@@ -531,7 +532,13 @@ var AssertionLimitationSchema$1 = Schema.Union([
 		kind: Schema.Literal("truncated"),
 		omittedBytes: NonNegativeIntegerSchema$1
 	}),
-	Schema.Struct({ kind: Schema.Literal("provider-limited") })
+	Schema.Struct({ kind: Schema.Literal("provider-limited") }),
+	Schema.Struct({
+		kind: Schema.Literal("capacity-limited"),
+		capturedItems: NonNegativeIntegerSchema$1,
+		knownTotalItems: NonNegativeIntegerSchema$1,
+		omittedBytes: Schema.NullOr(NonNegativeIntegerSchema$1)
+	})
 ]);
 var NoScoreContributionSchema = Schema.Struct({ state: Schema.Literal("not-scored") });
 var EarnedScoreContributionSchema = Schema.Struct({
@@ -1282,7 +1289,7 @@ Schema.String.check(Schema.makeFilter(isRecordFormatId, {
 var RecordFormatSchema = Schema.Literals([RECORD_FORMAT]).pipe(Schema.brand(RECORD_FORMAT_ID_BRAND));
 //#endregion
 //#region src/record/definition/canonical.ts
-var encoder$2 = new TextEncoder();
+var encoder$3 = new TextEncoder();
 /**
 * Blob refs are intentionally opaque to the generic canonicalizer. Their
 * bounded, deterministic projection makes them count toward the generic JSON
@@ -1298,8 +1305,8 @@ function failure$1(state, code, path) {
 }
 function compareUtf8(left, right) {
 	if (left === right) return 0;
-	const leftBytes = encoder$2.encode(left);
-	const rightBytes = encoder$2.encode(right);
+	const leftBytes = encoder$3.encode(left);
+	const rightBytes = encoder$3.encode(right);
 	const length = Math.min(leftBytes.byteLength, rightBytes.byteLength);
 	for (let index = 0; index < length; index += 1) {
 		const difference = leftBytes[index] - rightBytes[index];
@@ -1348,7 +1355,7 @@ function enter(value, depth, path, limits, state) {
 			failure$1(state, "record-json-invalid", path);
 			return false;
 		}
-		if (encoder$2.encode(value).byteLength > limits.maximumStringUtf8Bytes) {
+		if (encoder$3.encode(value).byteLength > limits.maximumStringUtf8Bytes) {
 			failure$1(state, "record-json-limit-exceeded", path);
 			return false;
 		}
@@ -1362,7 +1369,7 @@ function sortedObjectKeys(value, path, limits, state) {
 	const textKeys = keys;
 	for (const key of textKeys) {
 		if (!isUnicodeScalarString(key)) return failure$1(state, "record-json-invalid", [...path, key]);
-		if (key.length === 0 || encoder$2.encode(key).byteLength > limits.maximumKeyUtf8Bytes) return failure$1(state, "record-json-limit-exceeded", [...path, key]);
+		if (key.length === 0 || encoder$3.encode(key).byteLength > limits.maximumKeyUtf8Bytes) return failure$1(state, "record-json-limit-exceeded", [...path, key]);
 	}
 	return Object.freeze([...textKeys].sort(compareUtf8));
 }
@@ -1450,7 +1457,7 @@ function projectBlobRefsForBudget(value, options) {
 }
 function jsonBytes(value) {
 	const text = JSON.stringify(value);
-	return text === void 0 ? void 0 : encoder$2.encode(text).byteLength;
+	return text === void 0 ? void 0 : encoder$3.encode(text).byteLength;
 }
 /**
 * The only generic JSON normalizer. It intentionally knows no durable field
@@ -1882,6 +1889,16 @@ var persistences = /* @__PURE__ */ new WeakSet();
 var references = /* @__PURE__ */ new WeakMap();
 var referenceDeclarations = /* @__PURE__ */ new WeakMap();
 var referenceDeclarationRuns = /* @__PURE__ */ new WeakMap();
+/** Shared admission limits for producers using the current attachment encoder. */
+var RecordAttachmentEncodingLimits = Object.freeze({
+	maximumJsonBytes: 1048576,
+	maximumDepth: 64,
+	maximumNodes: 1e5,
+	maximumObjectKeys: 1e4,
+	maximumArrayItems: 1e5,
+	maximumKeyUtf8Bytes: 16384,
+	maximumStringUtf8Bytes: 1048576
+});
 function mintedReferenceDeclarationRuntime(value) {
 	const direct = referenceDeclarations.get(value);
 	if (direct !== void 0 || !SchemaAST.isAST(value) || !SchemaAST.isDeclaration(value)) return direct;
@@ -1904,15 +1921,7 @@ function isRecordAttachmentSchema(schema) {
 /** Defines only the current logical fact: no revision, migration, writer or storage selector. */
 function defineRecordAttachment(input) {
 	if (!validOwner(input.owner) || !isRecordAttachmentName(input.family) || !isRecordAttachmentSchema(input.schema) || typeof input.validate !== "undefined" && typeof input.validate !== "function") invalid$1();
-	const limits = {
-		maximumJsonBytes: 1048576,
-		maximumDepth: 64,
-		maximumNodes: 1e5,
-		maximumObjectKeys: 1e4,
-		maximumArrayItems: 1e5,
-		maximumKeyUtf8Bytes: 16384,
-		maximumStringUtf8Bytes: 1048576
-	};
+	const limits = RecordAttachmentEncodingLimits;
 	const definition = Object.freeze({
 		owner: input.owner,
 		family: input.family,
@@ -2202,6 +2211,24 @@ var RunGetDocumentSchema = Schema.Struct({
 });
 Schema.Union([RunListDocumentSchema, RunGetDocumentSchema]);
 //#endregion
+//#region src/model-slots.ts
+var modelText = Schema.String.check(Schema.isPattern(/\S/u));
+var slotKey = Schema.String.check(Schema.isPattern(/^[A-Za-z][A-Za-z0-9_-]{0,63}$(?![\s\S])/u));
+Schema.Record(slotKey, Schema.Struct({
+	model: modelText,
+	reasoningEffort: Schema.optionalKey(modelText)
+})).check(Schema.makeFilter((value) => Object.keys(value).length > 0 && Object.keys(value).length <= 64));
+var ResolvedModelSlotsSchema = Schema.Record(slotKey, Schema.Struct({
+	model: Schema.NullOr(modelText),
+	reasoningEffort: Schema.NullOr(modelText)
+})).check(Schema.makeFilter((value) => Object.keys(value).length <= 64));
+//#endregion
+//#region src/shared/adapter-cleanup.ts
+var AdapterCleanupTimeoutMsSchema = Schema.Finite.check(Schema.isInt(), Schema.isBetween({
+	minimum: 1,
+	maximum: 3e5
+}));
+//#endregion
 //#region src/record/model/run-context.ts
 /** The complete budget for one immutable, self-explaining Run context. */
 var RunContextLimits = Object.freeze({
@@ -2230,9 +2257,11 @@ var NonEmptyStringSchema = Schema.String.pipe(Schema.check(Schema.isMinLength(1)
 var AdapterIdentitySchema = Schema.Struct({
 	name: NonEmptyStringSchema,
 	contract: NonEmptyStringSchema,
-	behaviorRevision: Schema.NullOr(NonEmptyStringSchema)
+	behaviorRevision: Schema.NullOr(NonEmptyStringSchema),
+	cleanupTimeoutMs: Schema.optionalKey(AdapterCleanupTimeoutMsSchema)
 });
 var RunExecutionContextSchema = Schema.Struct({
+	models: Schema.optionalKey(ResolvedModelSlotsSchema),
 	adapter: AdapterIdentitySchema,
 	model: Schema.NullOr(Schema.String),
 	reasoningEffort: Schema.NullOr(Schema.String),
@@ -2242,7 +2271,7 @@ var RunExecutionContextSchema = Schema.Struct({
 		setup: Schema.Literals(["absent", "opaque"]),
 		teardown: Schema.Literals(["absent", "opaque"])
 	}))
-});
+}).check(Schema.makeFilter((value) => value.models === void 0 || value.model === (value.models.default?.model ?? null) && value.reasoningEffort === (value.models.default?.reasoningEffort ?? null)));
 var RunLabelsSchema = Schema.Record(Schema.String, Schema.String);
 /** Run Context is Core, not an Attachment. */
 var RunContextDefinition = defineRecordCore({
@@ -2650,7 +2679,7 @@ var PositiveSafeIntegerSchema$1 = Schema.Number.pipe(Schema.check(Schema.makeFil
 	identifier: "RecordPositiveSafeInteger",
 	description: "a positive JSON-safe integer"
 })));
-Schema.Number.pipe(Schema.check(Schema.makeFilter((value) => Number.isFinite(value) && value >= 0, {
+var FiniteNonNegativeNumberSchema = Schema.Number.pipe(Schema.check(Schema.makeFilter((value) => Number.isFinite(value) && value >= 0, {
 	identifier: "RecordFiniteNonNegativeNumber",
 	description: "a finite non-negative JSON number"
 })));
@@ -4185,40 +4214,97 @@ var AdapterCallPriceBuckets = Object.freeze([
 	"cache-read",
 	"cache-write"
 ]);
+function decimalParts(value) {
+	const [integer, fraction = ""] = value.split(".");
+	return Object.freeze({
+		digits: BigInt(`${integer}${fraction}`),
+		scale: fraction.length
+	});
+}
+function canonicalDecimal(parts) {
+	if (parts.digits === 0n) return "0";
+	if (parts.scale === 0) return parts.digits.toString();
+	const padded = parts.digits.toString().padStart(parts.scale + 1, "0");
+	const integer = padded.slice(0, -parts.scale);
+	const fraction = padded.slice(-parts.scale).replace(/0+$/u, "");
+	return fraction.length === 0 ? integer : `${integer}.${fraction}`;
+}
+/** Converts one finite non-negative JS config number to its exact canonical decimal spelling. */
+function canonicalDecimalFromNumber(value) {
+	if (!Number.isFinite(value) || value < 0) return void 0;
+	const text = value.toString().toLowerCase();
+	if (!text.includes("e")) return text.includes(".") ? text.replace(/\.?0+$/u, "") : text;
+	const [coefficient, exponentText] = text.split("e");
+	const exponent = Number(exponentText);
+	if (coefficient === void 0 || !Number.isSafeInteger(exponent)) return void 0;
+	const [integer, fraction = ""] = coefficient.split(".");
+	const digits = `${integer}${fraction}`;
+	const point = integer.length + exponent;
+	if (point <= 0) return canonicalDecimal({
+		digits: BigInt(digits),
+		scale: digits.length - point
+	});
+	if (point >= digits.length) return `${digits}${"0".repeat(point - digits.length)}`;
+	return canonicalDecimal({
+		digits: BigInt(digits),
+		scale: digits.length - point
+	});
+}
+function multiplyCanonicalDecimalPerMillion(rate, tokens) {
+	const value = decimalParts(rate);
+	return canonicalDecimal({
+		digits: value.digits * BigInt(tokens),
+		scale: value.scale + 6
+	});
+}
+function addCanonicalDecimals(values) {
+	if (values.length === 0) return "0";
+	const parts = values.map(decimalParts);
+	const scale = Math.max(...parts.map((value) => value.scale));
+	return canonicalDecimal({
+		digits: parts.reduce((sum, value) => sum + value.digits * 10n ** BigInt(scale - value.scale), 0n),
+		scale
+	});
+}
+/** Stable digest of the effective profile only; it is intentionally not the catalog snapshot digest. */
+function adapterCallPricingProfileDigest(value) {
+	const bytes = new TextEncoder().encode(JSON.stringify(value));
+	return `sha256:${new RecordSha256().update(bytes).digestHex()}`;
+}
 //#endregion
 //#region src/record/family/adapter-usage/schema.ts
-var Identity = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.trim().length > 0 && new TextEncoder().encode(value).byteLength <= 256 && !/[\u0000-\u001f\u007f]/u.test(value))));
-var Tokens = Schema.NullOr(NonNegativeSafeIntegerSchema$2);
+var Identity$1 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => value.trim().length > 0 && new TextEncoder().encode(value).byteLength <= 256 && !/[\u0000-\u001f\u007f]/u.test(value))));
+var Tokens$1 = Schema.NullOr(NonNegativeSafeIntegerSchema$2);
 var AdapterUsageCallRevision1Schema = Schema.Struct({
-	callId: Identity,
-	retryOf: Schema.NullOr(Identity),
-	provider: Schema.NullOr(Identity),
-	model: Schema.NullOr(Identity),
+	callId: Identity$1,
+	retryOf: Schema.NullOr(Identity$1),
+	provider: Schema.NullOr(Identity$1),
+	model: Schema.NullOr(Identity$1),
 	status: Schema.Literals([
 		"succeeded",
 		"failed",
 		"cancelled",
 		"unknown"
 	]),
-	inputTokens: Tokens,
-	inputTotalTokens: Tokens,
-	outputTokens: Tokens,
-	cacheReadTokens: Tokens,
-	cacheWriteTokens: Tokens
+	inputTokens: Tokens$1,
+	inputTotalTokens: Tokens$1,
+	outputTokens: Tokens$1,
+	cacheReadTokens: Tokens$1,
+	cacheWriteTokens: Tokens$1
 });
 var AdapterUsageRouteSchema = Schema.Struct({
-	transportProvider: Schema.NullOr(Identity),
-	endpointId: Schema.NullOr(Identity)
+	transportProvider: Schema.NullOr(Identity$1),
+	endpointId: Schema.NullOr(Identity$1)
 });
 var AdapterUsageReportedCostSchema = Schema.Struct({
 	amount: CanonicalDecimalSchema,
 	currency: CurrencyCodeSchema,
 	source: Schema.Struct({
 		kind: Schema.Literal("reported"),
-		id: Identity
+		id: Identity$1
 	})
 });
-var Digest = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => /^sha256:[0-9a-f]{64}$/u.test(value))));
+var Digest$1 = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => /^sha256:[0-9a-f]{64}$/u.test(value))));
 var NullableRateSchema = Schema.NullOr(CanonicalDecimalSchema);
 var AdapterCallPriceRatesSchema = Schema.Struct({
 	input: NullableRateSchema,
@@ -4228,16 +4314,16 @@ var AdapterCallPriceRatesSchema = Schema.Struct({
 });
 var AdapterCallPriceSourceSchema = Schema.Struct({
 	kind: Schema.Literal("configured-profile"),
-	id: Identity,
+	id: Identity$1,
 	asOf: Schema.NullOr(PositiveSafeIntegerSchema$1),
-	profileDigest: Digest
+	profileDigest: Digest$1
 });
 var AdapterCallPricingSchema = Schema.Struct({
 	basis: Schema.Literal("catalog-reference"),
 	currency: Schema.Literal("USD"),
 	source: AdapterCallPriceSourceSchema,
-	requestModel: Identity,
-	selector: Identity,
+	requestModel: Identity$1,
+	selector: Identity$1,
 	match: Schema.Literals(["exact", "provider-wildcard"]),
 	ratesPerMTok: AdapterCallPriceRatesSchema
 });
@@ -4253,28 +4339,38 @@ var AdapterCallPriceMissingSchema = Schema.Struct({
 });
 var AdapterCallPriceReceiptSchema = Schema.Struct({
 	kind: Schema.Literal("adapter-call-price-estimate"),
-	callId: Identity,
+	callId: Identity$1,
 	state: Schema.Literals(["complete", "partial"]),
 	amount: CanonicalDecimalSchema,
 	currency: Schema.Literal("USD"),
 	source: Schema.Struct({
 		kind: Schema.Literal("estimated"),
-		id: Identity
+		id: Identity$1
 	}),
 	pricing: AdapterCallPricingSchema,
 	charges: Schema.NonEmptyArray(AdapterCallPriceChargeSchema),
 	missing: Schema.Array(AdapterCallPriceMissingSchema)
 });
-var AdapterUsageCallSchema = Schema.Struct({
+var AdapterUsageModelSlotSchema = Schema.String.check(Schema.isPattern(/^[A-Za-z][A-Za-z0-9_-]{0,63}$(?![\s\S])/u));
+var AdapterUsageCallRevision2Schema = Schema.Struct({
 	...AdapterUsageCallRevision1Schema.fields,
 	route: AdapterUsageRouteSchema,
 	cost: Schema.NullOr(AdapterUsageReportedCostSchema)
 });
+var AdapterUsageCallSchema = Schema.Struct({
+	...AdapterUsageCallRevision2Schema.fields,
+	modelSlot: Schema.NullOr(AdapterUsageModelSlotSchema)
+});
 Object.freeze({ maximumCalls: 4e3 });
 Schema.Struct({
 	collection: CollectionStateSchema,
 	calls: Schema.Array(AdapterUsageCallRevision1Schema)
 });
+Schema.Struct({
+	collection: CollectionStateSchema,
+	calls: Schema.Array(AdapterUsageCallRevision2Schema),
+	priceReceipts: Schema.Array(AdapterCallPriceReceiptSchema)
+});
 Schema.Struct({
 	collection: CollectionStateSchema,
 	calls: Schema.Array(AdapterUsageCallSchema),
@@ -4282,6 +4378,310 @@ Schema.Struct({
 	priceReceipts: Schema.Array(AdapterCallPriceReceiptSchema)
 });
 //#endregion
+//#region src/record/family/judge-usage/schema.ts
+var JudgeUsageLimits = Object.freeze({
+	maximumCalls: 4e3,
+	maximumModelBytes: 8192,
+	maximumReceiptBytes: 32768,
+	maximumReceiptFields: 24
+});
+var encoder$2 = new TextEncoder();
+function boundedIdentity(maximumBytes) {
+	return Schema.String.check(Schema.makeFilter((value) => value.trim().length > 0 && !/[\ud800-\udfff]/u.test(value) && encoder$2.encode(value).byteLength <= maximumBytes && !/[\u0000-\u001f\u007f]/u.test(value)));
+}
+var Identity = boundedIdentity(256);
+/** @internal Used to validate observations before retaining their response fields. */
+var JudgeUsageModelSchema = boundedIdentity(JudgeUsageLimits.maximumModelBytes);
+var Digest = Schema.String.check(Schema.isPattern(/^sha256:[0-9a-f]{64}$/u));
+var Tokens = Schema.NullOr(NonNegativeSafeIntegerSchema$2);
+var NullableRate = Schema.NullOr(CanonicalDecimalSchema);
+/** Only these protocol facts may enter durable receipts; business text is excluded. */
+var JudgeUsageReceiptPaths = Object.freeze([
+	"model",
+	"provider",
+	"usage.completion_tokens",
+	"usage.cost",
+	"usage.input_tokens",
+	"usage.output_tokens",
+	"usage.prompt_tokens",
+	"usage.prompt_tokens_details.cache_write_tokens",
+	"usage.prompt_tokens_details.cached_tokens",
+	"usage.total_tokens"
+]);
+var ReceiptFieldSchema = Schema.Struct({
+	path: Schema.Literals(JudgeUsageReceiptPaths),
+	value: Schema.Union([
+		Schema.String.check(Schema.makeFilter((value) => !/[\ud800-\udfff]/u.test(value) && encoder$2.encode(value).byteLength <= JudgeUsageLimits.maximumModelBytes && !/[\u0000-\u001f\u007f]/u.test(value))),
+		FiniteNonNegativeNumberSchema.check(Schema.makeFilter((value) => !Object.is(value, -0))),
+		Schema.Null
+	])
+});
+var ReceiptSchema = Schema.Struct({
+	state: Schema.Literals(["available", "unavailable"]),
+	reason: Schema.NullOr(Schema.Literals([
+		"response-unavailable",
+		"cancelled",
+		"response-too-large",
+		"invalid-json",
+		"usage-not-reported",
+		"invalid-usage",
+		"response-model-too-large"
+	])),
+	responseDigest: Schema.NullOr(Digest),
+	fields: Schema.Array(ReceiptFieldSchema)
+}).check(Schema.makeFilter((receipt) => {
+	if (receipt.fields.length > JudgeUsageLimits.maximumReceiptFields || encoder$2.encode(JSON.stringify(receipt)).byteLength > JudgeUsageLimits.maximumReceiptBytes || receipt.fields.some((field, index) => index > 0 && receipt.fields[index - 1].path >= field.path)) return false;
+	if (receipt.state === "available") return receipt.fields.some((field) => field.value !== null) && receipt.responseDigest !== null && (receipt.reason === null || receipt.reason === "invalid-usage" || receipt.reason === "usage-not-reported" || receipt.reason === "response-model-too-large");
+	return receipt.fields.length === 0 && receipt.reason !== null && (receipt.reason === "invalid-json" || receipt.reason === "invalid-usage" || receipt.reason === "usage-not-reported" || receipt.reason === "response-model-too-large" ? receipt.responseDigest !== null : receipt.responseDigest === null);
+}));
+var JudgeUsageCallSchema = Schema.Struct({
+	callId: Identity,
+	entryIndex: NonNegativeSafeIntegerSchema$2,
+	entryId: AssertionEntryIdSchema,
+	logicalOrdinal: PositiveSafeIntegerSchema$1,
+	transmissionOrdinal: PositiveSafeIntegerSchema$1,
+	operation: Schema.Literals([
+		"score",
+		"classify",
+		"extract",
+		"batchClassify"
+	]),
+	requestModel: JudgeUsageModelSchema,
+	transportProvider: Schema.Literals([
+		"openai",
+		"vercel",
+		"openrouter",
+		"typesafe"
+	]),
+	provider: Schema.NullOr(Identity),
+	model: Schema.NullOr(JudgeUsageModelSchema),
+	status: Schema.Literals([
+		"succeeded",
+		"failed",
+		"cancelled",
+		"unknown"
+	]),
+	httpStatus: Schema.NullOr(NonNegativeSafeIntegerSchema$2.check(Schema.makeFilter((value) => value >= 100 && value <= 599))),
+	inputTokens: Tokens,
+	inputTotalTokens: Tokens,
+	outputTokens: Tokens,
+	cacheReadTokens: Tokens,
+	cacheWriteTokens: Tokens,
+	cost: Schema.NullOr(Schema.Struct({
+		amount: CanonicalDecimalSchema,
+		currency: CurrencyCodeSchema,
+		source: Schema.Struct({
+			kind: Schema.Literal("reported"),
+			id: Identity
+		})
+	})),
+	receipt: ReceiptSchema
+}).check(Schema.makeFilter((call) => validCall$1(call)));
+var JudgePriceReceiptSchema = Schema.Struct({
+	kind: Schema.Literal("judge-call-price-estimate"),
+	callId: Identity,
+	state: Schema.Literals(["complete", "partial"]),
+	amount: CanonicalDecimalSchema,
+	currency: Schema.Literal("USD"),
+	source: Schema.Struct({
+		kind: Schema.Literal("estimated"),
+		id: Identity
+	}),
+	pricing: Schema.Struct({
+		basis: Schema.Literal("catalog-reference"),
+		currency: Schema.Literal("USD"),
+		source: Schema.Struct({
+			kind: Schema.Literal("configured-profile"),
+			id: Identity,
+			asOf: Schema.NullOr(PositiveSafeIntegerSchema$1),
+			profileDigest: Digest
+		}),
+		requestModel: JudgeUsageModelSchema,
+		selector: JudgeUsageModelSchema,
+		match: Schema.Literals(["exact", "provider-wildcard"]),
+		ratesPerMTok: Schema.Struct({
+			input: NullableRate,
+			output: NullableRate,
+			cacheRead: NullableRate,
+			cacheWrite: NullableRate
+		})
+	}),
+	charges: Schema.NonEmptyArray(Schema.Struct({
+		bucket: Schema.Literals(AdapterCallPriceBuckets),
+		tokens: NonNegativeSafeIntegerSchema$2,
+		ratePerMTok: NullableRate,
+		amount: CanonicalDecimalSchema
+	})),
+	missing: Schema.Array(Schema.Struct({
+		bucket: Schema.Literals(AdapterCallPriceBuckets),
+		reason: Schema.Literals(["tokens-unknown", "rate-unknown"])
+	}))
+}).check(Schema.makeFilter((receipt) => validPriceReceipt(receipt)));
+Schema.Struct({
+	collection: CollectionStateSchema,
+	calls: Schema.Array(JudgeUsageCallSchema),
+	priceReceipts: Schema.Array(JudgePriceReceiptSchema)
+}).check(Schema.makeFilter((value) => validateJudgeUsageAttachment(value).length === 0));
+function validCall$1(call) {
+	if (call.callId !== `judge:${call.entryIndex}:${call.logicalOrdinal}:${call.transmissionOrdinal}`) return false;
+	const buckets = [
+		call.inputTokens,
+		call.cacheReadTokens,
+		call.cacheWriteTokens
+	];
+	const known = buckets.filter((value) => value !== null);
+	const sum = known.reduce((total, value) => total + value, 0);
+	if (!Number.isSafeInteger(sum) || call.inputTotalTokens !== null && (sum > call.inputTotalTokens || known.length === 3 && sum !== call.inputTotalTokens)) return false;
+	if (call.inputTotalTokens !== null && call.outputTokens !== null && !Number.isSafeInteger(call.inputTotalTokens + call.outputTokens)) return false;
+	const fields = new Map(call.receipt.fields.map((field) => [field.path, field.value]));
+	for (const field of call.receipt.fields) {
+		if (field.value === null) continue;
+		if (field.path === "model") {
+			if (typeof field.value !== "string" || !Schema.is(JudgeUsageModelSchema)(field.value)) return false;
+		} else if (field.path === "provider") {
+			if (call.transportProvider !== "openrouter" || typeof field.value !== "string" || !Schema.is(Identity)(field.value)) return false;
+		} else if (field.path === "usage.cost") {
+			const amount = typeof field.value === "number" ? canonicalDecimalFromNumber(field.value) : field.value;
+			if (call.transportProvider !== "openrouter" || amount === void 0 || !Schema.is(CanonicalDecimalSchema)(amount)) return false;
+		} else if (typeof field.value !== "number" || !Schema.is(NonNegativeSafeIntegerSchema$2)(field.value) || (call.transportProvider === "typesafe" ? ![
+			"usage.input_tokens",
+			"usage.output_tokens",
+			"usage.total_tokens"
+		].includes(field.path) : ["usage.input_tokens", "usage.output_tokens"].includes(field.path)) || field.path === "usage.prompt_tokens_details.cache_write_tokens" && call.transportProvider !== "openrouter") return false;
+	}
+	if ((fields.get("model") ?? null) !== call.model || (fields.get("provider") ?? null) !== call.provider) return false;
+	const inputPath = call.transportProvider === "typesafe" ? "usage.input_tokens" : "usage.prompt_tokens";
+	const outputPath = call.transportProvider === "typesafe" ? "usage.output_tokens" : "usage.completion_tokens";
+	if (call.inputTotalTokens !== null && fields.get(inputPath) !== call.inputTotalTokens || call.outputTokens !== null && fields.get(outputPath) !== call.outputTokens) return false;
+	if (call.receipt.reason !== "invalid-usage" && (typeof fields.get(inputPath) === "number" && call.inputTotalTokens === null || typeof fields.get(outputPath) === "number" && call.outputTokens === null || typeof fields.get("usage.prompt_tokens_details.cached_tokens") === "number" && call.cacheReadTokens === null || typeof fields.get("usage.prompt_tokens_details.cache_write_tokens") === "number" && call.cacheWriteTokens === null)) return false;
+	const total = fields.get("usage.total_tokens");
+	if (typeof total === "number" && (call.inputTotalTokens !== null && call.inputTotalTokens > total || call.outputTokens !== null && call.outputTokens > total || call.inputTotalTokens !== null && call.outputTokens !== null && call.inputTotalTokens + call.outputTokens !== total)) return false;
+	if (call.transportProvider === "typesafe" && buckets.some((value) => value !== null)) return false;
+	if (call.transportProvider !== "typesafe" && call.inputTotalTokens === 0 && buckets.some((value) => value !== 0)) return false;
+	if (call.cacheReadTokens !== null && fields.get("usage.prompt_tokens_details.cached_tokens") !== call.cacheReadTokens && !(call.inputTotalTokens === 0 && call.cacheReadTokens === 0 && !fields.has("usage.prompt_tokens_details.cached_tokens"))) return false;
+	if (call.cacheWriteTokens !== null && fields.get("usage.prompt_tokens_details.cache_write_tokens") !== call.cacheWriteTokens && !(call.inputTotalTokens === 0 && call.cacheWriteTokens === 0 && !fields.has("usage.prompt_tokens_details.cache_write_tokens"))) return false;
+	if (call.inputTokens !== null && (call.inputTotalTokens === null || call.cacheReadTokens === null || call.cacheWriteTokens === null || call.inputTokens !== call.inputTotalTokens - call.cacheReadTokens - call.cacheWriteTokens)) return false;
+	if (call.inputTotalTokens !== null && call.cacheReadTokens !== null && call.cacheWriteTokens !== null && call.inputTokens === null) return false;
+	const rawCost = fields.get("usage.cost");
+	if (rawCost !== void 0 && rawCost !== null && call.cost === null) return false;
+	if (call.cost !== null) {
+		const raw = rawCost;
+		const amount = typeof raw === "number" ? canonicalDecimalFromNumber(raw) : raw;
+		if (call.transportProvider !== "openrouter" || call.cost.currency !== "USD" || call.cost.source.id !== "openrouter.usage.cost" || call.cost.amount !== amount) return false;
+	}
+	return true;
+}
+function validPriceReceipt(receipt) {
+	const profile = receipt.pricing;
+	const expectedSelector = profile.match === "exact" ? profile.requestModel : profile.requestModel.includes("/") ? `${profile.requestModel.slice(0, profile.requestModel.indexOf("/"))}/*` : void 0;
+	if (profile.selector !== expectedSelector || receipt.source.id !== profile.source.id || profile.source.profileDigest !== adapterCallPricingProfileDigest({
+		basis: profile.basis,
+		currency: profile.currency,
+		source: {
+			kind: profile.source.kind,
+			id: profile.source.id,
+			asOf: profile.source.asOf
+		},
+		requestModel: profile.requestModel,
+		selector: profile.selector,
+		match: profile.match,
+		ratesPerMTok: {
+			input: profile.ratesPerMTok.input,
+			output: profile.ratesPerMTok.output,
+			cacheRead: profile.ratesPerMTok.cacheRead,
+			cacheWrite: profile.ratesPerMTok.cacheWrite
+		}
+	})) return false;
+	const charges = new Map(receipt.charges.map((charge) => [charge.bucket, charge]));
+	const missing = new Map(receipt.missing.map((entry) => [entry.bucket, entry]));
+	if (charges.size !== receipt.charges.length || missing.size !== receipt.missing.length || AdapterCallPriceBuckets.some((bucket) => Number(charges.has(bucket)) + Number(missing.has(bucket)) !== 1)) return false;
+	for (const charge of receipt.charges) {
+		const rate = bucketRate(profile.ratesPerMTok, charge.bucket);
+		if (charge.ratePerMTok !== rate || charge.tokens > 0 && rate === null || charge.amount !== (rate === null ? "0" : multiplyCanonicalDecimalPerMillion(rate, charge.tokens))) return false;
+	}
+	return receipt.state === (missing.size === 0 ? "complete" : "partial") && receipt.amount === addCanonicalDecimals(receipt.charges.map((charge) => charge.amount));
+}
+function bucketRate(rates, bucket) {
+	switch (bucket) {
+		case "input": return rates.input;
+		case "output": return rates.output;
+		case "cache-read": return rates.cacheRead;
+		case "cache-write": return rates.cacheWrite;
+	}
+}
+function bucketTokens(call, bucket) {
+	switch (bucket) {
+		case "input": return call.inputTokens;
+		case "output": return call.outputTokens;
+		case "cache-read": return call.cacheReadTokens;
+		case "cache-write": return call.cacheWriteTokens;
+	}
+}
+function validateJudgeUsageAttachment(value) {
+	const issue = (path) => [recordAttachmentIssue("record-attachment-schema-invalid", path)];
+	if (value.calls.length > JudgeUsageLimits.maximumCalls) return issue(["calls"]);
+	const calls = /* @__PURE__ */ new Map();
+	const entries = /* @__PURE__ */ new Map();
+	const entryIds = /* @__PURE__ */ new Map();
+	const transmissions = /* @__PURE__ */ new Map();
+	for (const call of value.calls) {
+		if (!validCall$1(call) || calls.has(call.callId) || entries.has(call.entryIndex) && entries.get(call.entryIndex) !== call.entryId || entryIds.has(call.entryId) && entryIds.get(call.entryId) !== call.entryIndex) return issue(["calls", "callId"]);
+		calls.set(call.callId, call);
+		entries.set(call.entryIndex, call.entryId);
+		entryIds.set(call.entryId, call.entryIndex);
+		const key = `${call.entryIndex}:${call.logicalOrdinal}`;
+		let logical = transmissions.get(key);
+		if (logical === void 0) {
+			logical = {
+				operation: call.operation,
+				model: call.requestModel,
+				provider: call.transportProvider,
+				ordinals: /* @__PURE__ */ new Set()
+			};
+			transmissions.set(key, logical);
+		}
+		if (logical.operation !== call.operation || logical.model !== call.requestModel || logical.provider !== call.transportProvider) return issue(["calls", "logicalOrdinal"]);
+		logical.ordinals.add(call.transmissionOrdinal);
+	}
+	for (const logical of transmissions.values()) for (let ordinal = 1; ordinal <= logical.ordinals.size; ordinal++) if (!logical.ordinals.has(ordinal)) return issue(["calls", "transmissionOrdinal"]);
+	const seen = /* @__PURE__ */ new Set();
+	for (const receipt of value.priceReceipts) {
+		const call = calls.get(receipt.callId);
+		if (call === void 0 || seen.has(receipt.callId) || call.cost !== null || receipt.pricing.requestModel !== call.requestModel || !validPriceReceipt(receipt)) return issue(["priceReceipts", "callId"]);
+		seen.add(receipt.callId);
+		const charges = new Map(receipt.charges.map((charge) => [charge.bucket, charge]));
+		const missing = new Map(receipt.missing.map((entry) => [entry.bucket, entry]));
+		for (const bucket of AdapterCallPriceBuckets) {
+			const tokens = bucketTokens(call, bucket);
+			const rate = bucketRate(receipt.pricing.ratesPerMTok, bucket);
+			const charge = charges.get(bucket);
+			if (tokens === null ? charge !== void 0 || missing.get(bucket)?.reason !== "tokens-unknown" : tokens === 0 || rate !== null ? charge?.tokens !== tokens : charge !== void 0 || missing.get(bucket)?.reason !== "rate-unknown") return issue(["priceReceipts", "charges"]);
+		}
+	}
+	return [];
+}
+//#endregion
+//#region src/o11y/adapter-usage-projection.ts
+/** Tuple order is stable across hosts, with missing identities before strings. */
+function compareAdapterModelGroups(left, right) {
+	for (const key of [
+		"modelSlot",
+		"provider",
+		"model"
+	]) {
+		const a = left[key];
+		const b = right[key];
+		if (a === b) continue;
+		if (a === null) return -1;
+		if (b === null) return 1;
+		return a < b ? -1 : 1;
+	}
+	return 0;
+}
+function compareJudgeUsageCalls(left, right) {
+	return left.entryIndex - right.entryIndex || left.logicalOrdinal - right.logicalOrdinal || left.transmissionOrdinal - right.transmissionOrdinal;
+}
+//#endregion
 //#region src/record/family/protocol-values.ts
 /** Canonical finite protocol vocabularies shared by current receipt owners and projections. */
 var AGENT_TURN_OUTCOME = Object.freeze({
@@ -4800,6 +5200,83 @@ var LinkSchema = Schema.Union([Schema.Struct({
 		reason: Schema.String
 	})
 })]);
+var DisplayRoleSchema = Schema.Literals([
+	"user",
+	"assistant",
+	"system",
+	"other"
+]);
+var DisplayScalarSchema = Schema.Union([
+	Schema.String,
+	FiniteNumberSchema,
+	Schema.Boolean,
+	Schema.Null
+]);
+var DisplayFieldsSchema = Schema.Array(Schema.Struct({
+	label: Schema.String,
+	value: DisplayScalarSchema
+}));
+var InputDisplayBlockSchema = Schema.Union([
+	Schema.Struct({
+		kind: Schema.Literal("text"),
+		text: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("message"),
+		role: DisplayRoleSchema,
+		speaker: Schema.optional(Schema.String),
+		text: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("fields"),
+		fields: DisplayFieldsSchema
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("code"),
+		language: Schema.optional(Schema.String),
+		text: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("image"),
+		artifactId: BoundedIdentifierSchema,
+		alt: Schema.String
+	})
+]);
+/** Persisted image blocks carry the descriptor fixed at acceptance. */
+var ExecutionDisplayBlockRecordSchema = Schema.Union([
+	Schema.Struct({
+		kind: Schema.Literal("text"),
+		text: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("message"),
+		role: DisplayRoleSchema,
+		speaker: Schema.optional(Schema.String),
+		text: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("fields"),
+		fields: DisplayFieldsSchema
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("code"),
+		language: Schema.optional(Schema.String),
+		text: Schema.String
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("image"),
+		artifactId: BoundedIdentifierSchema,
+		alt: Schema.String,
+		mediaType: Schema.Literals([
+			"image/png",
+			"image/jpeg",
+			"image/webp",
+			"image/gif"
+		]),
+		byteLength: NonNegativeSafeIntegerSchema,
+		sha256: Sha256Schema
+	})
+]);
 var InputEvidenceSchema = Schema.Struct({
 	key: BoundedIdentifierSchema,
 	label: Schema.String,
@@ -4834,7 +5311,8 @@ var InputEventSchema = Schema.Struct({
 			"excluded",
 			"unknown"
 		])
-	})))
+	}))),
+	display: Schema.optional(Schema.Array(InputDisplayBlockSchema))
 });
 Schema.Struct({
 	traceId: BoundedIdentifierSchema,
@@ -4895,7 +5373,8 @@ var ExecutionTraceEventRecordSchema = Schema.Struct({
 			"excluded",
 			"unknown"
 		])
-	}))
+	})),
+	display: Schema.optional(Schema.NonEmptyArray(ExecutionDisplayBlockRecordSchema))
 });
 Schema.Union([ExecutionTraceHeaderRecordSchema, ExecutionTraceEventRecordSchema]);
 Object.freeze({
@@ -4914,7 +5393,15 @@ Object.freeze({
 	maximumDetailPreviewBytes: 2048,
 	maximumDetailBytes: 524288,
 	maximumOutlineEvents: 32,
-	maximumOutlineBytes: 65536
+	maximumOutlineBytes: 65536,
+	maximumDisplayBlocksPerEvent: 4,
+	maximumDisplayBytesPerEvent: 8192,
+	maximumDisplayFields: 16,
+	maximumDisplayLabelBytes: 128,
+	maximumDisplayAltBytes: 512,
+	maximumDisplayPreviewBytes: 1024,
+	maximumOutlineEventBytes: 8192,
+	maximumDisplayInlineImageBytes: 16777216
 });
 //#endregion
 //#region src/record/family/file-changes/schema.ts
@@ -5131,7 +5618,13 @@ var AssertionLimitationSchema = Schema.Union([
 		kind: Schema.Literal("truncated"),
 		omittedBytes: Schema.Number
 	}),
-	Schema.Struct({ kind: Schema.Literal("provider-limited") })
+	Schema.Struct({ kind: Schema.Literal("provider-limited") }),
+	Schema.Struct({
+		kind: Schema.Literal("capacity-limited"),
+		capturedItems: Schema.Number,
+		knownTotalItems: Schema.Number,
+		omittedBytes: Schema.NullOr(Schema.Number)
+	})
 ]);
 var OverviewIssueSchema = Schema.Union([
 	Schema.Struct({
@@ -5223,6 +5716,7 @@ var OverviewCoverageSchema = Schema.Union([Schema.Struct({
 		"truncated",
 		"redacted",
 		"provider-limited",
+		"capacity-limited",
 		"not-collected",
 		"source-unavailable",
 		"producer-failed",
@@ -5321,6 +5815,24 @@ var InspectionOverviewResultSchema = Schema.Struct({
 	cells: Schema.Array(OverviewCellSchema)
 });
 var InspectionExperimentResultSchema = Schema.Struct({
+	costSummary: Schema.suspend(() => ExperimentCostSummarySchema),
+	modelUsage: Schema.Struct({
+		attempts: Schema.Array(Schema.Struct({
+			locator: Schema.String,
+			originRunId: Schema.String,
+			usage: Schema.suspend(() => Schema.Struct({
+				state: InspectionAttemptUsageResultSchema.fields.state,
+				configuredModels: InspectionAttemptUsageResultSchema.fields.configuredModels,
+				modelGroups: InspectionAttemptUsageResultSchema.fields.modelGroups,
+				judgeUsage: JudgeUsageSummarySchema,
+				totalCosts: InspectionAttemptUsageResultSchema.fields.totalCosts,
+				totals: InspectionAttemptUsageResultSchema.fields.totals
+			}))
+		})),
+		totalAttemptCount: NonNegativeSafeIntegerSchema$2,
+		omittedAttemptCount: NonNegativeSafeIntegerSchema$2,
+		unresolvedAttemptCount: NonNegativeSafeIntegerSchema$2
+	}).check(Schema.makeFilter((usage) => usage.attempts.length <= 64 && usage.totalAttemptCount === usage.attempts.length + usage.omittedAttemptCount && usage.attempts.every((entry, index) => index === 0 || usage.attempts[index - 1].originRunId < entry.originRunId || usage.attempts[index - 1].originRunId === entry.originRunId && usage.attempts[index - 1].locator < entry.locator))),
 	experiment: OverviewExperimentSchema,
 	cells: Schema.Array(OverviewCellSchema)
 });
@@ -5427,7 +5939,8 @@ var AttemptLimitationSchema = Schema.Union([
 			"sampled",
 			"truncated",
 			"redacted",
-			"provider-limited"
+			"provider-limited",
+			"capacity-limited"
 		]),
 		limitations: Schema.Array(AssertionLimitationSchema)
 	}),
@@ -5725,6 +6238,56 @@ var TraceDiagnosticsSchema = Schema.Struct({
 	hasMore: Schema.Boolean,
 	omittedDiagnosticCount: Schema.Number
 });
+var ExecutionDisplayPreviewTextSchema = Schema.Struct({
+	preview: Schema.String,
+	omittedBytes: Schema.Number
+});
+var ExecutionDisplayRoleSchema = Schema.Literals([
+	"user",
+	"assistant",
+	"system",
+	"other"
+]);
+var ExecutionDisplayPreviewSchema = Schema.Union([Schema.Struct({ state: Schema.Literal("absent") }), Schema.Struct({
+	state: Schema.Literal("present"),
+	blocks: Schema.Array(Schema.Union([
+		Schema.Struct({
+			kind: Schema.Literal("text"),
+			text: ExecutionDisplayPreviewTextSchema
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("message"),
+			role: ExecutionDisplayRoleSchema,
+			speaker: Schema.optional(Schema.String),
+			text: ExecutionDisplayPreviewTextSchema
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("fields"),
+			fields: Schema.Array(Schema.Struct({
+				label: Schema.String,
+				value: Schema.Union([
+					ExecutionDisplayPreviewTextSchema,
+					Schema.Number,
+					Schema.Boolean,
+					Schema.Null
+				])
+			}))
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("code"),
+			language: Schema.optional(Schema.String),
+			text: ExecutionDisplayPreviewTextSchema
+		}),
+		Schema.Struct({
+			kind: Schema.Literal("image"),
+			artifactId: Schema.String,
+			alt: Schema.String,
+			mediaType: Schema.String,
+			byteLength: Schema.Number,
+			sha256: Schema.String
+		})
+	]))
+})]);
 var TraceItemBase = {
 	itemId: ItemIdSchema$1,
 	turnId: Schema.String,
@@ -5861,7 +6424,8 @@ var InspectionTraceResultSchema = Schema.Struct({
 				key: Schema.String,
 				label: Schema.String
 			})),
-			scopeMemberships: ExecutionTraceEventRecordSchema.fields.scopeMemberships
+			scopeMemberships: ExecutionTraceEventRecordSchema.fields.scopeMemberships,
+			display: ExecutionDisplayPreviewSchema
 		})),
 		identityIndex: Schema.Struct({
 			traceIds: Schema.Array(Schema.String),
@@ -6134,9 +6698,12 @@ var UsageCostTotalSchema = Schema.Struct({
 	value: Schema.String,
 	observationCount: Schema.Number
 });
+var validUsageCurrency = Schema.is(CurrencyCodeSchema);
+var UsageDecimalSchema = Schema.String.check(Schema.isPattern(/^(?:0|[1-9][0-9]*)(?:\.[0-9]*[1-9])?$(?![\s\S])/u));
+var UsageCurrencySchema = Schema.String.check(Schema.makeFilter((value) => validUsageCurrency(value)));
 var EffectiveCostSchema = Schema.Struct({
-	amount: Schema.String,
-	currency: Schema.String,
+	amount: UsageDecimalSchema,
+	currency: UsageCurrencySchema,
 	source: Schema.Struct({
 		kind: Schema.Literals(["reported", "estimated"]),
 		id: Schema.String
@@ -6159,19 +6726,156 @@ var EffectiveCostTotalSchema = Schema.Struct({
 		"mixed"
 	])),
 	values: Schema.Array(Schema.Struct({
-		currency: Schema.String,
-		value: Schema.String,
+		currency: UsageCurrencySchema,
+		value: UsageDecimalSchema,
 		source: Schema.Literals([
 			"reported",
 			"estimated",
 			"mixed"
 		]),
-		coveredCalls: Schema.Number,
-		reportedCalls: Schema.Number,
-		estimatedCalls: Schema.Number
+		coveredCalls: NonNegativeSafeIntegerSchema$2,
+		reportedCalls: NonNegativeSafeIntegerSchema$2,
+		estimatedCalls: NonNegativeSafeIntegerSchema$2
 	})),
-	totalCalls: Schema.Number
+	totalCalls: NonNegativeSafeIntegerSchema$2
 });
+var RecordedCallCountSchema = NonNegativeSafeIntegerSchema$2.check(Schema.isLessThanOrEqualTo(4e3));
+var ModelGroupTokenTotalSchema = Schema.Struct({
+	state: Schema.Literals([
+		"available",
+		"partial",
+		"unavailable"
+	]),
+	value: Schema.NullOr(NonNegativeSafeIntegerSchema$2),
+	observationCount: RecordedCallCountSchema
+}).check(Schema.makeFilter((value) => value.state === "unavailable" === (value.value === null)));
+var ConfiguredModelsSchema = Schema.Union([Schema.Struct({ state: Schema.Literal("not-recorded") }), Schema.Struct({
+	state: Schema.Literal("available"),
+	bindings: Schema.Array(Schema.Struct({
+		modelSlot: AdapterUsageModelSlotSchema,
+		model: Schema.NullOr(Schema.String.check(Schema.isPattern(/\S/u))),
+		reasoningEffort: Schema.NullOr(Schema.String.check(Schema.isPattern(/\S/u))),
+		recordedCalls: Schema.NullOr(RecordedCallCountSchema)
+	})).check(Schema.makeFilter((bindings) => bindings.length <= 64 && bindings.every((entry, index) => index === 0 || bindings[index - 1].modelSlot < entry.modelSlot)))
+})]);
+var ModelGroupSchema = Schema.Struct({
+	modelSlot: Schema.NullOr(AdapterUsageModelSlotSchema),
+	provider: AdapterUsageCallSchema.fields.provider,
+	model: AdapterUsageCallSchema.fields.model,
+	recordedCalls: RecordedCallCountSchema.check(Schema.isGreaterThan(0)),
+	tokens: Schema.Struct({
+		inputTotalTokens: ModelGroupTokenTotalSchema,
+		outputTokens: ModelGroupTokenTotalSchema,
+		totalTokens: ModelGroupTokenTotalSchema
+	}),
+	costs: EffectiveCostTotalSchema
+}).check(Schema.makeFilter((group) => group.costs.totalCalls === group.recordedCalls && Object.values(group.tokens).every((total) => total.observationCount <= group.recordedCalls)));
+var ModelGroupsSchema = Schema.Union([Schema.Struct({
+	state: Schema.Literal("available"),
+	basis: Schema.Literal("recorded-calls"),
+	groups: Schema.Array(ModelGroupSchema).check(Schema.makeFilter((groups) => groups.length <= 64 && groups.every((entry, index) => index === 0 || compareAdapterModelGroups(groups[index - 1], entry) < 0))),
+	totalGroupCount: RecordedCallCountSchema,
+	groupsTruncated: Schema.Boolean,
+	omittedGroupCount: RecordedCallCountSchema
+}).check(Schema.makeFilter((value) => value.totalGroupCount === value.groups.length + value.omittedGroupCount && value.groups.length === Math.min(value.totalGroupCount, 64) && value.groupsTruncated === value.omittedGroupCount > 0)), Schema.Struct({
+	state: Schema.Literal("unavailable"),
+	basis: Schema.Literals([
+		"recorded-calls",
+		"reported-sends",
+		"unavailable"
+	]),
+	reason: Schema.Literals([
+		"source-invalid",
+		"usage-not-recorded",
+		"physical-call-identity-not-recorded"
+	]),
+	groups: Schema.Tuple([]),
+	totalGroupCount: Schema.Null,
+	groupsTruncated: Schema.Literal(false),
+	omittedGroupCount: Schema.Literal(0)
+})]);
+var TotalUsageCostsSchema = Schema.Struct({
+	state: Schema.Literals([
+		"complete",
+		"partial",
+		"unavailable"
+	]),
+	values: Schema.Array(Schema.Struct({
+		currency: UsageCurrencySchema,
+		value: UsageDecimalSchema,
+		source: Schema.Literals([
+			"reported",
+			"estimated",
+			"mixed"
+		])
+	})),
+	missingSources: Schema.Array(Schema.Literals(["application", "judge"])).check(Schema.makeFilter((sources) => sources.length <= 2 && sources.every((source, index) => index === 0 || sources[index - 1] === "application" && source === "judge")))
+}).check(Schema.makeFilter((value) => value.state === (value.missingSources.length === 0 ? "complete" : value.values.length === 0 ? "unavailable" : "partial") && value.values.every((entry, index) => index === 0 || value.values[index - 1].currency < entry.currency)));
+var ExperimentCostSummarySchema = Schema.Struct({
+	scope: Schema.Literal("latest-recorded-slots"),
+	totalCosts: TotalUsageCostsSchema,
+	coverage: Schema.Struct({
+		selectedSlotCount: NonNegativeSafeIntegerSchema$2,
+		resolvedSlotCount: NonNegativeSafeIntegerSchema$2,
+		originAttemptCount: NonNegativeSafeIntegerSchema$2,
+		completeAttemptCount: NonNegativeSafeIntegerSchema$2,
+		partialAttemptCount: NonNegativeSafeIntegerSchema$2,
+		unavailableAttemptCount: NonNegativeSafeIntegerSchema$2,
+		unresolvedSlotCount: NonNegativeSafeIntegerSchema$2
+	}).check(Schema.makeFilter((value) => value.selectedSlotCount === value.resolvedSlotCount + value.unresolvedSlotCount && value.originAttemptCount <= value.resolvedSlotCount && value.originAttemptCount === value.completeAttemptCount + value.partialAttemptCount + value.unavailableAttemptCount))
+});
+var JudgeCostTotalsSchema = EffectiveCostTotalSchema.check(Schema.makeFilter((costs) => costs.totalCalls <= 4e3 && costs.source === null === (costs.values.length === 0) && costs.values.every((entry, index) => entry.coveredCalls <= entry.reportedCalls + entry.estimatedCalls && entry.reportedCalls + entry.estimatedCalls <= costs.totalCalls && entry.source === (entry.reportedCalls === 0 ? "estimated" : entry.estimatedCalls === 0 ? "reported" : "mixed") && (index === 0 || costs.values[index - 1].currency < entry.currency)) && costs.values.reduce((count, entry) => count + entry.reportedCalls + entry.estimatedCalls, 0) <= costs.totalCalls && (costs.state !== "unavailable" || costs.values.length === 0) && (costs.state !== "complete" || costs.values.reduce((count, entry) => count + entry.coveredCalls, 0) === costs.totalCalls)));
+var JudgeUsageUnavailableSchema = Schema.Union([Schema.Struct({
+	state: Schema.Literal("unavailable"),
+	reason: Schema.Literal("judge-usage-not-recorded")
+}), Schema.Struct({
+	state: Schema.Literal("invalid"),
+	reason: Schema.Literal("judge-usage-source-invalid")
+})]);
+var JudgeUsageSummaryFields = {
+	state: Schema.Literals(["complete", "partial"]),
+	coverage: Schema.Literal("physical-transmissions"),
+	collection: CollectionStateSchema,
+	totals: Schema.Struct({
+		requests: ModelGroupTokenTotalSchema,
+		inputTotalTokens: ModelGroupTokenTotalSchema,
+		outputTokens: ModelGroupTokenTotalSchema,
+		totalTokens: ModelGroupTokenTotalSchema,
+		costs: JudgeCostTotalsSchema
+	})
+};
+var JudgeUsageAvailableSummarySchema = Schema.Struct(JudgeUsageSummaryFields).check(Schema.makeFilter((usage) => {
+	const requests = usage.totals.requests;
+	return usage.state === usage.collection.state && requests.value === requests.observationCount && requests.state === (usage.state === "complete" ? "available" : "partial") && usage.totals.costs.totalCalls === requests.value && (usage.state === "complete" || usage.totals.costs.state !== "complete") && [
+		usage.totals.inputTotalTokens,
+		usage.totals.outputTokens,
+		usage.totals.totalTokens
+	].every((total) => total.observationCount <= requests.observationCount && (total.state !== "available" || usage.state === "complete" && total.observationCount === requests.observationCount)) && (requests.value !== 0 || usage.state !== "complete" || [
+		usage.totals.inputTotalTokens,
+		usage.totals.outputTokens,
+		usage.totals.totalTokens
+	].every((total) => total.state === "available" && total.value === 0) && usage.totals.costs.state === "complete");
+}));
+var JudgeUsageSummarySchema = Schema.Union([JudgeUsageUnavailableSchema, JudgeUsageAvailableSummarySchema]);
+var JudgeUsageSchema = Schema.Union([JudgeUsageUnavailableSchema, Schema.Struct({
+	...JudgeUsageSummaryFields,
+	calls: Schema.Array(JudgeUsageCallSchema),
+	callsTruncated: Schema.Boolean,
+	omittedCallCount: RecordedCallCountSchema,
+	priceReceipts: Schema.Array(JudgePriceReceiptSchema)
+}).check(Schema.makeFilter((usage) => Schema.is(JudgeUsageAvailableSummarySchema)({
+	state: usage.state,
+	coverage: usage.coverage,
+	collection: usage.collection,
+	totals: usage.totals
+}) && usage.calls.length <= 128 && usage.calls.length + usage.omittedCallCount === usage.totals.requests.value && usage.callsTruncated === usage.omittedCallCount > 0 && usage.calls.every((call, index) => index === 0 || compareJudgeUsageCalls(usage.calls[index - 1], call) < 0) && utf8ByteLength$2(JSON.stringify({
+	calls: usage.calls,
+	priceReceipts: usage.priceReceipts
+})) <= 131072 && validateJudgeUsageAttachment({
+	collection: usage.collection,
+	calls: usage.calls,
+	priceReceipts: usage.priceReceipts
+}).length === 0))]);
 var UsageTotalsSchema = Schema.Struct({
 	inputTotalTokens: Schema.optional(UsageNumericTotalSchema),
 	inputTokens: UsageNumericTotalSchema,
@@ -6189,6 +6893,10 @@ var UsageTotalsSchema = Schema.Struct({
 	costs: Schema.optional(EffectiveCostTotalSchema)
 });
 var InspectionAttemptUsageResultSchema = Schema.Struct({
+	configuredModels: ConfiguredModelsSchema,
+	modelGroups: ModelGroupsSchema,
+	judgeUsage: JudgeUsageSchema,
+	totalCosts: TotalUsageCostsSchema,
 	source: Schema.optional(Schema.Literal("adapter")),
 	coverage: Schema.optional(Schema.Literal("recorded-calls")),
 	calls: Schema.optional(Schema.Array(AdapterUsageInspectionCallSchema)),
@@ -6393,6 +7101,72 @@ var InspectionAttemptDiffResultSchema = Schema.Union([
 	})
 ]);
 //#endregion
+//#region src/inspection/project-result.ts
+var LocatorSchema = Schema.String.check(Schema.makeFilter((value) => ATTEMPT_LOCATOR_PATTERN.test(value)));
+var PositionFields = {
+	experimentId: ExperimentIdSchema,
+	evalId: EvalIdSchema,
+	attemptOrdinal: NonNegativeSafeIntegerSchema$2
+};
+var PreviousResultSchema = Schema.Struct({
+	sourceRunId: RunIdSchema,
+	locator: LocatorSchema
+});
+var ProjectIssueSchema = Schema.suspend(() => Schema.Union([
+	Schema.Null,
+	Schema.Boolean,
+	Schema.Number,
+	Schema.String,
+	Schema.Array(ProjectIssueSchema),
+	Schema.Record(Schema.String, ProjectIssueSchema)
+]));
+var InspectionProjectGapReasonSchema = Schema.Literals([
+	"no-result",
+	"pending",
+	"not-published",
+	"identity-mismatch",
+	"outcome-ineligible",
+	"score-incomplete",
+	"evidence-unavailable",
+	"timeout-exceeded",
+	"adoption-unproven"
+]);
+var InspectionProjectSlotSchema = Schema.Union([Schema.Struct({
+	...PositionFields,
+	state: Schema.Literal("reuse"),
+	sourceRunId: RunIdSchema,
+	locator: LocatorSchema,
+	relation: Schema.Literals(["origin", "reference"]),
+	action: Schema.Literals([
+		"executed",
+		"carried",
+		"accepted"
+	])
+}), Schema.Struct({
+	...PositionFields,
+	state: Schema.Literal("gap"),
+	reason: InspectionProjectGapReasonSchema,
+	issues: Schema.Array(ProjectIssueSchema),
+	sourceRunId: Schema.NullOr(RunIdSchema),
+	previous: Schema.NullOr(PreviousResultSchema)
+})]);
+/** Current quality metrics retain the aggregate shapes owned by Inspection. */
+var InspectionProjectResultSchema = Schema.Struct({
+	targetIdentity: Schema.NonEmptyString,
+	coverage: Schema.Struct({
+		expected: NonNegativeSafeIntegerSchema$2,
+		covered: NonNegativeSafeIntegerSchema$2,
+		gaps: NonNegativeSafeIntegerSchema$2
+	}),
+	slots: Schema.Array(InspectionProjectSlotSchema),
+	...InspectionOverviewResultSchema.fields,
+	history: Schema.Array(Schema.Struct({
+		...PositionFields,
+		sourceRunId: RunIdSchema,
+		locator: Schema.NullOr(LocatorSchema)
+	}))
+}).check(Schema.makeFilter((value) => value.coverage.covered + value.coverage.gaps === value.coverage.expected && value.slots.length === value.coverage.expected && value.slots.filter((slot) => slot.state === "reuse").length === value.coverage.covered));
+//#endregion
 //#region src/inspection/protocol.ts
 var AttemptLocatorSchema = Schema.String.pipe(Schema.refine((value) => ATTEMPT_LOCATOR_PATTERN.test(value), {
 	identifier: "AttemptLocator",
@@ -6402,6 +7176,7 @@ var ItemIdSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isItemId)))
 var ToolOccurrenceIdSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isToolOccurrenceId)));
 var CommandIdSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isCommandId)));
 var RunIdsSchema = Schema.Array(RunIdSchema);
+var ProjectExperimentIdsSchema = Schema.Array(ExperimentIdSchema).check(Schema.makeFilter((ids) => ids.length > 0 && new Set(ids).size === ids.length));
 var operation = (kind, fields) => Schema.Struct({
 	kind: Schema.Literal(kind),
 	...fields
@@ -6521,8 +7296,18 @@ var RunsCompareResultSchema = Schema.Struct({
 	}))
 });
 var spec = (fields) => Object.freeze(fields);
-/** The sole 16-operation protocol owner. Every request, result and descriptor projection is derived from this registry. */
+/** The sole protocol catalog owner. Every request, result and descriptor projection is derived from this registry. */
 var inspectionProtocolRegistry = Object.freeze({
+	"project.get": spec({
+		request: operation("project.get", { experimentIds: Schema.optional(ProjectExperimentIdsSchema) }),
+		result: { project: InspectionProjectResultSchema },
+		factKinds: [
+			"current-project",
+			"core",
+			"assertions",
+			"attempt-cost"
+		]
+	}),
 	"overview.get": spec({
 		request: operation("overview.get", { runIds: Schema.optional(RunIdsSchema) }),
 		result: { overview: InspectionOverviewResultSchema },
@@ -6538,7 +7323,10 @@ var inspectionProtocolRegistry = Object.freeze({
 		factKinds: [
 			"core",
 			"assertions",
-			"attempt-cost"
+			"attempt-cost",
+			"agent-turns",
+			"adapter-usage",
+			"judge-usage"
 		]
 	}),
 	"runs.list": spec({
@@ -6619,6 +7407,7 @@ var inspectionProtocolRegistry = Object.freeze({
 			traceId: Schema.optional(Schema.String),
 			sourceId: Schema.optional(Schema.String),
 			actorId: Schema.optional(Schema.String),
+			eventType: Schema.optional(Schema.String),
 			continuation: Schema.optional(Schema.String)
 		}),
 		result: { trace: InspectionTraceResultSchema },
@@ -6662,7 +7451,11 @@ var inspectionProtocolRegistry = Object.freeze({
 	"attempt.usage": spec({
 		request: operation("attempt.usage", { locator: AttemptLocatorSchema }),
 		result: { usage: InspectionAttemptUsageResultSchema },
-		factKinds: ["agent-turns", "adapter-usage"]
+		factKinds: [
+			"agent-turns",
+			"adapter-usage",
+			"judge-usage"
+		]
 	}),
 	"attempt.diff": spec({
 		request: operation("attempt.diff", { locator: AttemptLocatorSchema }),
@@ -6719,9 +7512,7 @@ var successSchema = (id, entry) => {
 		operation: Schema.Literal(id),
 		...entry.result
 	});
-	if (id === "runs.list") return RunsListSuccessMetadataSchema.pipe(fields);
-	if (id === "runs.compare") return CompareSuccessMetadataSchema.pipe(fields);
-	return SuccessMetadataSchema.pipe(fields);
+	return id === "runs.list" ? RunsListSuccessMetadataSchema.pipe(fields) : id === "runs.compare" ? CompareSuccessMetadataSchema.pipe(fields) : SuccessMetadataSchema.pipe(fields);
 };
 var InspectionSuccessDocumentSchema = Schema.Union(specs.map(([id, entry]) => successSchema(id, entry)));
 var explanationSchema = (id, entry) => {
@@ -6753,7 +7544,8 @@ var InspectionFailureDocumentSchema = Schema.Struct({
 			"inspection-operation-failed",
 			"inspection-result-invalid",
 			"evidence-budget-exceeded",
-			"restart-required"
+			"restart-required",
+			"current-target-unavailable"
 		]),
 		reason: Schema.String,
 		identity: Schema.optional(Schema.Struct({ runId: Schema.String })),
@@ -6994,22 +7786,26 @@ function primitiveRequest(operation, value) {
 		return;
 	}
 	if (canonicalScoreMatchAuditJson(system) !== systemMessage.content || canonicalScoreMatchAuditJson(user) !== userMessage.content) return void 0;
+	const systemKeys = operation === "score" ? [
+		"operation",
+		"rubric",
+		"anchors"
+	] : operation === "classify" || operation === "batchClassify" ? [
+		"operation",
+		"rubric",
+		"choices"
+	] : [
+		"operation",
+		"rubric",
+		"maxItems"
+	];
+	const evidenceIds = operation === "classify" ? record(system)?.evidenceIds : void 0;
+	if (evidenceIds !== void 0 && !validEvidenceIds(evidenceIds)) return void 0;
 	const systemInput = exact(system, [
-		...operation === "score" ? [
-			"operation",
-			"rubric",
-			"anchors"
-		] : operation === "classify" || operation === "batchClassify" ? [
-			"operation",
-			"rubric",
-			"choices"
-		] : [
-			"operation",
-			"rubric",
-			"maxItems"
-		],
+		...systemKeys,
 		"protocol",
-		"instruction"
+		"instruction",
+		...evidenceIds === void 0 ? [] : ["evidenceIds"]
 	]);
 	const userInput = exact(user, operation === "batchClassify" ? ["material", "items"] : ["material"]);
 	if (systemInput === void 0 || userInput === void 0 || systemInput.protocol !== protocol || !text(systemInput.instruction) || systemInput.operation !== operation || !text(systemInput.rubric)) return void 0;
@@ -7028,7 +7824,10 @@ function primitiveRequest(operation, value) {
 	if (!Array.isArray(systemInput.choices) || systemInput.choices.length < 2 || systemInput.choices.length > 32 || systemInput.choices.some((choice) => !text(choice))) return void 0;
 	const choices = new Set(systemInput.choices);
 	if (choices.size !== systemInput.choices.length) return void 0;
-	if (operation === "classify") return Object.freeze({ choices });
+	if (operation === "classify") return Object.freeze({
+		choices,
+		...evidenceIds === void 0 ? {} : { evidenceIds: new Set(evidenceIds) }
+	});
 	if (!Array.isArray(userInput.items) || userInput.items.length === 0 || userInput.items.length > 32) return void 0;
 	const itemIds = /* @__PURE__ */ new Set();
 	for (const raw of userInput.items) {
@@ -7058,8 +7857,12 @@ function primitiveOutput(operation, output, request) {
 		return item !== void 0 && unit(item.measurement) && text(item.rationale);
 	}
 	if (operation === "classify") {
-		const item = exact(value, ["choice", "rationale"]);
-		return item !== void 0 && text(item.choice) && text(item.rationale) && requestInput.choices?.has(item.choice) === true;
+		const item = exact(value, [
+			"choice",
+			"rationale",
+			...requestInput.evidenceIds === void 0 ? [] : ["citations"]
+		]);
+		return item !== void 0 && text(item.choice) && text(item.rationale) && requestInput.choices?.has(item.choice) === true && (requestInput.evidenceIds === void 0 || validEvidenceIds(item.citations, true) && item.citations.every((id) => requestInput.evidenceIds.has(id)));
 	}
 	if (operation === "extract") {
 		const item = exact(value, [
@@ -7187,7 +7990,9 @@ function mappingRequestAndOutput(mappingValue, response, requestModel) {
 		"items",
 		"material"
 	];
-	const input = exactKeys(mapping.input, inputKeys);
+	const evidenceIds = operation === "classify" ? record(mapping.input)?.evidenceIds : void 0;
+	if (evidenceIds !== void 0 && !validEvidenceIds(evidenceIds)) return void 0;
+	const input = exactKeys(mapping.input, [...inputKeys, ...evidenceIds === void 0 ? [] : ["evidenceIds"]]);
 	if (input === void 0 || !text(input.rubric)) return void 0;
 	let parsedResponse;
 	try {
@@ -7580,7 +8385,7 @@ function readScoreMatchAudit(value, expectedName, expectedMeasurement, imageCont
 			"digest",
 			"chunkByteLengths"
 		]);
-		if (outer === void 0 || manifest === void 0 || manifest.schemaVersion !== 1 && manifest.schemaVersion !== 2 && manifest.schemaVersion !== 3 || manifest.protocol !== expectedProtocol || !Array.isArray(outer.content) || outer.content.length === 0 || !Array.isArray(manifest.chunkByteLengths) || manifest.chunkByteLengths.length !== outer.content.length || !positiveInteger(manifest.byteLength, 262144) || typeof manifest.digest !== "string" || !/^[a-f0-9]{64}$/u.test(manifest.digest)) return Object.freeze({ state: "invalid" });
+		if (outer === void 0 || manifest === void 0 || manifest.schemaVersion !== 1 && manifest.schemaVersion !== 2 && manifest.schemaVersion !== 3 || manifest.protocol !== expectedProtocol || !Array.isArray(outer.content) || outer.content.length === 0 || outer.content.length > 2050 || !Array.isArray(manifest.chunkByteLengths) || manifest.chunkByteLengths.length !== outer.content.length || !positiveInteger(manifest.byteLength, 8388608) || typeof manifest.digest !== "string" || !/^[a-f0-9]{64}$/u.test(manifest.digest)) return Object.freeze({ state: "invalid" });
 		const chunks = [];
 		for (let index = 0; index < outer.content.length; index += 1) {
 			const chunk = outer.content[index];
@@ -7620,7 +8425,10 @@ function readScoreMatchAudit(value, expectedName, expectedMeasurement, imageCont
 			"maxMaterialBytes",
 			"maxAuditBytes"
 		]);
-		if (audit === void 0 || audit.schemaVersion !== manifest.schemaVersion || audit.protocol !== expectedProtocol || definition === void 0 || !text(definition.name) || !text(definition.version) || expectedName !== void 0 && definition.name !== expectedName || typeof definition.config !== "string" || typeof definition.digest !== "string" || limits === void 0 || !positiveInteger(limits.maxCalls, 16) || !positiveInteger(limits.maxMaterialBytes, 49152) || !positiveInteger(limits.maxAuditBytes, 262144) || manifest.byteLength > limits.maxAuditBytes) return Object.freeze({ state: "invalid" });
+		if (audit === void 0 || audit.schemaVersion !== manifest.schemaVersion || audit.protocol !== expectedProtocol || definition === void 0 || !text(definition.name) || !text(definition.version) || expectedName !== void 0 && definition.name !== expectedName || typeof definition.config !== "string" || typeof definition.digest !== "string" || limits === void 0 || !positiveInteger(limits.maxCalls, 16) || !positiveInteger(limits.maxMaterialBytes, 4194304) || !positiveInteger(limits.maxAuditBytes, 8388608) || manifest.byteLength > limits.maxAuditBytes || utf8ByteLength$2(canonicalScoreMatchAuditJson({
+			manifest,
+			content: chunks
+		})) > limits.maxAuditBytes) return Object.freeze({ state: "invalid" });
 		if (canonicalScoreMatchAuditJson(JSON.parse(definition.config)) !== definition.config || definition.digest !== scoreMatchDefinitionDigest({
 			name: definition.name,
 			version: definition.version,
@@ -7628,7 +8436,8 @@ function readScoreMatchAudit(value, expectedName, expectedMeasurement, imageCont
 			limits
 		})) return Object.freeze({ state: "invalid" });
 		const images = manifest.schemaVersion === 3 ? validImages(audit.images, audit.input, imageContent) : void 0;
-		if (typeof audit.input !== "string" || utf8ByteLength$2(audit.input) > limits.maxMaterialBytes || canonicalScoreMatchAuditJson(JSON.parse(audit.input)) !== audit.input || manifest.schemaVersion === 3 && images === void 0 || !Array.isArray(audit.calls) || audit.calls.length > limits.maxCalls + 1 || audit.calls.length > limits.maxCalls && record(audit.calls.at(-1))?.state !== "rejected" || audit.calls.some((call, index) => manifest.schemaVersion === 1 ? !validCall(call, index + 1) : manifest.schemaVersion === 2 ? !validTypeSafeCall(call, index + 1) : !validV3Call(call, index + 1, images))) return Object.freeze({ state: "invalid" });
+		const initialMaterialRejected = record(audit.result)?.state === "unavailable" && record(audit.result)?.code === "score-match-material-budget" && Array.isArray(audit.calls) && audit.calls.length === 0;
+		if (typeof audit.input !== "string" || utf8ByteLength$2(audit.input) > limits.maxMaterialBytes && !initialMaterialRejected || canonicalScoreMatchAuditJson(JSON.parse(audit.input)) !== audit.input || manifest.schemaVersion === 3 && images === void 0 || !Array.isArray(audit.calls) || audit.calls.length > limits.maxCalls + 1 || audit.calls.length > limits.maxCalls && record(audit.calls.at(-1))?.state !== "rejected" || audit.calls.some((call, index) => manifest.schemaVersion === 1 ? !validCall(call, index + 1) : manifest.schemaVersion === 2 ? !validTypeSafeCall(call, index + 1) : !validV3Call(call, index + 1, images))) return Object.freeze({ state: "invalid" });
 		const result = record(audit.result);
 		if (!(result?.state === "measured" ? exact(result, ["state", "value"]) !== void 0 && unit(result.value) && (expectedMeasurement === void 0 || Object.is(result.value, expectedMeasurement)) : failure(result) || result?.state === "interrupted" && exact(result, ["state"]) !== void 0) || result?.state === "measured" && audit.calls.some((call) => record(call)?.state !== "admitted" || record(record(call)?.result)?.state !== "completed")) return Object.freeze({ state: "invalid" });
 		return Object.freeze({
@@ -7639,5 +8448,8 @@ function readScoreMatchAudit(value, expectedName, expectedMeasurement, imageCont
 		return Object.freeze({ state: "invalid" });
 	}
 }
+function validEvidenceIds(value, empty = false) {
+	return Array.isArray(value) && value.length <= 16384 && (empty || value.length > 0) && value.every((id) => text(id) && id.trim() !== "" && new TextEncoder().encode(id).length <= 128 && !/[\u0000-\u001f\u007f]/u.test(id)) && new Set(value).size === value.length;
+}
 //#endregion
 export { INSPECTION_BEHAVIOR_VERSION, INSPECTION_OPERATION_IDS, InspectionDiscoveryDocumentSchema, InspectionDocumentSchema, InspectionExplanationDocumentSchema, InspectionFailureDocumentSchema, InspectionOperationIdSchema, InspectionRequestSchema, InspectionSuccessDocumentSchema, QUERY_PROTOCOL, canonicalInspectionJson, canonicalJsonValue, closeInspectionJson, decodeInspectionDocument, decodeInspectionOperation, decodeInspectionRequest, inspectionProtocolRegistry, narrowInspectionExplanation, narrowInspectionSuccess, readScoreMatchAudit };