@iowarp/clio-coder 0.3.8 → 0.4.0

package/src/domains/eval/execution-provenance.ts

@@ -0,0 +1,240 @@
+import { createHash } from "node:crypto";
+import { discoverAgentRecipes } from "../agents/registry.js";
+import { agentSpecFingerprint, normalizeAgentSpec } from "../agents/spec.js";
+import type { RunReceipt } from "../dispatch/types.js";
+import { loadFragments } from "../prompts/fragment-loader.js";
+import { createSafetyPolicyEngine } from "../safety/policy-engine.js";
+import type { EvalLedgerSnapshot, EvalPromptManifestObservation } from "./metrics/tracked.js";
+import type { EvalExecutionEnvelopeV1, EvalPromptFragmentIdentityV1 } from "./schema/execution-envelope.js";
+import { EVAL_EXECUTION_ENVELOPE_SCHEMA_V1 } from "./schema/execution-envelope.js";
+import type { EvalSuiteTargetV2, EvalSuiteTaskV2 } from "./schema/suite.js";
+
+/** Bounded execution facts a deterministic grader can surface from an in-process dispatch. */
+export interface EvalExecutionObservationV1 {
+	compositionHash: string | null;
+	target: string | null;
+	wireModel: string | null;
+	runtime: string | null;
+	thinkingLevel: string | null;
+	toolSignature: string | null;
+	autonomy: string | null;
+	policyHashes: { rulePack: string | null; project: string | null };
+	projectContext: {
+		tier: string | null;
+		contentHash: string | null;
+		chars: number | null;
+		sections: string[];
+		rulesApplied: string[];
+		operatorProfileApplied: boolean | null;
+	} | null;
+}
+
+export interface BuildEvalExecutionEnvelopeInput {
+	task: EvalSuiteTaskV2;
+	target: EvalSuiteTargetV2;
+	cwd: string | null;
+	receipt: RunReceipt | null;
+	ledger: EvalLedgerSnapshot;
+	observation?: EvalExecutionObservationV1;
+}
+
+/**
+ * Bind one behavioral result to the exact model-facing and policy-facing
+ * identity available at the runner boundary. Nulls mean the declared
+ * machinery-only mode has no such model concept; they never stand in for a
+ * guessed value.
+ */
+export function buildEvalExecutionEnvelopeV1(input: BuildEvalExecutionEnvelopeInput): EvalExecutionEnvelopeV1 {
+	const scenario = input.task.behavioral;
+	if (scenario === undefined) throw new Error(`behavioral task ${input.task.id} has no behavioral scenario`);
+	const manifest = input.ledger.promptManifests.at(-1) ?? null;
+	const contextSnapshot = input.ledger.contextSnapshots.at(-1) ?? null;
+	const recipe = recipeIdentity(
+		input,
+		scenario.execution.subject.kind === "worker" ? scenario.execution.subject.role : null,
+	);
+	const policy = policyIdentity(input.cwd, input.receipt, input.observation);
+	const autonomy =
+		input.receipt?.autonomyEnforcement?.autonomy ?? input.observation?.autonomy ?? input.task.runner.autonomy ?? null;
+	const promptFragments = promptFragmentIdentities(manifest, recipe, autonomy);
+	const compositionHash =
+		input.receipt?.staticCompositionHash ??
+		input.observation?.compositionHash ??
+		manifest?.systemPromptHash ??
+		contextSnapshot?.promptHash ??
+		null;
+	const projectContext = projectContextIdentity(input, manifest, promptFragments);
+	return {
+		schema: EVAL_EXECUTION_ENVELOPE_SCHEMA_V1,
+		prompt: { fragments: promptFragments, compositionHash },
+		recipe: recipe === null ? null : { id: recipe.id, version: recipe.version, contentHash: recipe.contentHash },
+		target: input.receipt?.targetId ?? input.observation?.target ?? input.target.id,
+		wireModel:
+			input.receipt?.wireModelId ?? input.observation?.wireModel ?? contextSnapshot?.modelId ?? input.target.model ?? null,
+		runtime: input.receipt?.runtimeId ?? input.observation?.runtime ?? contextSnapshot?.runtimeId ?? null,
+		thinkingLevel:
+			input.receipt?.runtimeResolution?.effectiveThinkingLevel ??
+			input.observation?.thinkingLevel ??
+			manifest?.thinkingLevel ??
+			input.target.thinking ??
+			null,
+		toolSignature:
+			input.receipt?.toolSignature ?? input.observation?.toolSignature ?? contextSnapshot?.toolSignature ?? null,
+		autonomy,
+		policyHashes: policy,
+		projectContext,
+		corpus: { ...scenario.corpus },
+	};
+}
+
+function recipeIdentity(
+	input: BuildEvalExecutionEnvelopeInput,
+	role: string | null,
+): { id: string; version: number; contentHash: string; personaHash: string } | null {
+	const id = input.receipt?.agentId ?? input.task.runner.agent ?? role;
+	if (id === null || input.cwd === null) return null;
+	try {
+		const recipe = discoverAgentRecipes(input.cwd).find((entry) => entry.id === id);
+		if (recipe === undefined) return null;
+		return {
+			id: recipe.id,
+			version: recipe.version,
+			contentHash: agentSpecFingerprint(normalizeAgentSpec(recipe)),
+			personaHash: sha256(recipe.body),
+		};
+	} catch {
+		return null;
+	}
+}
+
+function promptFragmentIdentities(
+	manifest: EvalPromptManifestObservation | null,
+	recipe: { id: string; version: number; personaHash: string } | null,
+	autonomy: string | null,
+): EvalPromptFragmentIdentityV1[] {
+	let versions = new Map<string, number>();
+	try {
+		versions = new Map([...loadFragments().byId.values()].map((fragment) => [fragment.id, fragment.version]));
+	} catch {
+		// The manifest still carries exact hashes; only authored versions become unavailable.
+	}
+	if (manifest !== null) {
+		return manifest.fragments
+			.map((fragment) => ({
+				id: fragment.id,
+				version: versions.get(fragment.id) ?? ("unversioned" as const),
+				contentHash: fragment.contentHash,
+			}))
+			.sort((left, right) => left.id.localeCompare(right.id));
+	}
+	if (recipe === null) return [];
+	const selected = ["identity.clio-worker", "operating.contract", "operating.worker"];
+	if (autonomy !== null) selected.push(`safety.${autonomy}`);
+	const fragments: EvalPromptFragmentIdentityV1[] = [];
+	try {
+		const table = loadFragments();
+		for (const id of selected) {
+			const fragment = table.byId.get(id);
+			if (fragment !== undefined) {
+				fragments.push({ id, version: fragment.version, contentHash: fragment.contentHash });
+			}
+		}
+	} catch {
+		// The composition hash remains authoritative when resource discovery fails.
+	}
+	fragments.push({ id: `persona.${recipe.id}`, version: recipe.version, contentHash: recipe.personaHash });
+	return fragments.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function policyIdentity(
+	cwd: string | null,
+	receipt: RunReceipt | null,
+	observation: EvalExecutionObservationV1 | undefined,
+): EvalExecutionEnvelopeV1["policyHashes"] {
+	const sealed = receipt?.reproducibility?.safetyPolicy;
+	if (sealed !== undefined) return { rulePack: sealed.rulePackHash, project: sealed.projectPolicyHash };
+	if (observation !== undefined) return { ...observation.policyHashes };
+	if (cwd === null) return { rulePack: null, project: null };
+	try {
+		const metadata = createSafetyPolicyEngine({ cwd }).metadata();
+		return { rulePack: metadata.rulePackHash, project: metadata.projectPolicyHash };
+	} catch {
+		return { rulePack: null, project: null };
+	}
+}
+
+function projectContextIdentity(
+	input: BuildEvalExecutionEnvelopeInput,
+	manifest: EvalPromptManifestObservation | null,
+	fragments: ReadonlyArray<EvalPromptFragmentIdentityV1>,
+): EvalExecutionEnvelopeV1["projectContext"] {
+	const receipt = input.receipt;
+	if (receipt?.projectContext !== undefined) {
+		const sections = [...(receipt.projectContext.sections ?? [])].sort();
+		const hasContentBearingContext = sections.some((section) => section !== "workspace-root");
+		return {
+			kind: "worker",
+			tier: receipt.projectContext.tier,
+			contentHash: hasContentBearingContext ? (receipt.projectContext.contentHash ?? null) : null,
+			chars: hasContentBearingContext ? (receipt.projectContext.chars ?? null) : null,
+			sections,
+			rulesApplied: [...(receipt.rulesApplied ?? [])].sort(),
+			operatorProfileApplied: receipt.operatorProfileApplied ?? null,
+		};
+	}
+	const observed = input.observation?.projectContext;
+	if (observed !== undefined && observed !== null) {
+		const sections = [...observed.sections].sort();
+		const hasContentBearingContext = sections.some((section) => section !== "workspace-root");
+		return {
+			kind: "worker",
+			tier: observed.tier,
+			contentHash: hasContentBearingContext ? observed.contentHash : null,
+			chars: hasContentBearingContext ? observed.chars : null,
+			sections,
+			rulesApplied: [...observed.rulesApplied].sort(),
+			operatorProfileApplied: observed.operatorProfileApplied,
+		};
+	}
+	if (manifest !== null) {
+		const contextFragments = fragments.filter((fragment) => fragment.id.startsWith("context."));
+		const preload = manifest.projectPreload;
+		const identity = {
+			preload,
+			fragments: contextFragments.map((fragment) => [fragment.id, fragment.contentHash]),
+		};
+		return {
+			kind: "session",
+			tier: preload?.mode ?? null,
+			contentHash: sha256(stableJson(identity)),
+			chars: preload?.chars ?? null,
+			sections: contextFragments.map((fragment) => fragment.id).sort(),
+			rulesApplied: [],
+			operatorProfileApplied: contextFragments.some((fragment) => fragment.id === "context.operator-profile"),
+		};
+	}
+	return {
+		kind: "none",
+		tier: null,
+		contentHash: null,
+		chars: null,
+		sections: [],
+		rulesApplied: [],
+		operatorProfileApplied: null,
+	};
+}
+
+function stableJson(value: unknown): string {
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+	if (typeof value === "object" && value !== null) {
+		return `{${Object.entries(value as Record<string, unknown>)
+			.sort(([left], [right]) => left.localeCompare(right))
+			.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+			.join(",")}}`;
+	}
+	return JSON.stringify(value);
+}
+
+function sha256(value: string): string {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}

package/src/domains/eval/inventory.ts

@@ -0,0 +1,113 @@
+/**
+ * Bounded newest-first listing of the eval reports this installation stored.
+ *
+ * The store has always been addressed by id: `eval report <evalId>` and
+ * `eval compare <a> <b>` both require the operator to already know which report
+ * they want. Nothing enumerated the directory, so a surface that wants to offer
+ * the choice had to invent the enumeration. This is that enumeration, and it is
+ * a store concern rather than a wire concern: it decides which files are in the
+ * window and hands back parsed artifacts, and says nothing about which of their
+ * fields may leave the host.
+ */
+
+import { readdir } from "node:fs/promises";
+import { loadEvalArtifactV4 } from "./artifacts/store.js";
+import type { EvalArtifactV4 } from "./schema/artifact.js";
+import { evalRoot } from "./store.js";
+
+/**
+ * The exact shape `createEvalId` mints: an ISO stamp with its separators
+ * stripped, the first eight characters of the suite hash, and a random suffix.
+ */
+const EVAL_ID_PATTERN = /^eval-(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(\d{3})Z-([0-9a-f]{8})-([0-9a-f]{12})$/u;
+
+export interface EvalStoredReport {
+	readonly evalId: string;
+	/**
+	 * The instant the run started, read back out of the id.
+	 *
+	 * Null unless the id is one this harness minted and its embedded suite-hash
+	 * prefix agrees with the suite the artifact names. An artifact has no
+	 * timestamp field of its own, so the id is the only record of when it ran,
+	 * and a stamp read off an id that does not otherwise match its contents is
+	 * not a fact worth reporting.
+	 */
+	readonly startedAt: string | null;
+	readonly artifact: EvalArtifactV4;
+}
+
+export interface EvalStoreListing {
+	/** False when the installation has no eval store at all, which reads differently from an empty one. */
+	readonly available: boolean;
+	/** Reports on disk before the window bound. */
+	readonly stored: number;
+	readonly reports: readonly EvalStoredReport[];
+	/**
+	 * Files inside the window the current parser refused.
+	 *
+	 * Counted rather than dropped silently. Routing accepts artifact v4 only, so
+	 * a retired shape still on disk is a real thing in this store, and a listing
+	 * that quietly skipped it would report a smaller store than the operator has.
+	 */
+	readonly unreadable: number;
+}
+
+/** The stamp an id carries, without checking it against anything. */
+function idStamp(evalId: string): { startedAt: string; suiteHashPrefix: string } | null {
+	const match = EVAL_ID_PATTERN.exec(evalId);
+	if (match === null) return null;
+	const [, year, month, day, hour, minute, second, millisecond, suiteHashPrefix] = match;
+	const startedAt = `${year}-${month}-${day}T${hour}:${minute}:${second}.${millisecond}Z`;
+	const parsed = new Date(startedAt);
+	if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== startedAt) return null;
+	return { startedAt, suiteHashPrefix: suiteHashPrefix as string };
+}
+
+/** Newest first. An id this harness did not mint sorts oldest rather than throwing. */
+function byNewest(left: string, right: string): number {
+	const leftStamp = idStamp(left)?.startedAt ?? "";
+	const rightStamp = idStamp(right)?.startedAt ?? "";
+	if (leftStamp !== rightStamp) return leftStamp < rightStamp ? 1 : -1;
+	return left < right ? 1 : -1;
+}
+
+export async function listEvalReports(dataDir: string, limit: number): Promise<EvalStoreListing> {
+	let entries: string[];
+	try {
+		entries = await readdir(evalRoot(dataDir));
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return { available: false, stored: 0, reports: [], unreadable: 0 };
+		}
+		throw error;
+	}
+	const ids = entries
+		.filter((entry) => entry.endsWith(".json"))
+		.map((entry) => entry.slice(0, -".json".length))
+		.sort(byNewest);
+	const reports: EvalStoredReport[] = [];
+	let unreadable = 0;
+	for (const evalId of ids.slice(0, limit)) {
+		let artifact: EvalArtifactV4;
+		try {
+			artifact = await loadEvalArtifactV4(dataDir, evalId);
+		} catch {
+			unreadable += 1;
+			continue;
+		}
+		// The id inside the file is authoritative. A file whose stem disagrees with
+		// it was renamed or copied in, and the two names it now answers to are not
+		// the same report.
+		if (artifact.evalId !== evalId) {
+			unreadable += 1;
+			continue;
+		}
+		const stamp = idStamp(evalId);
+		reports.push({
+			evalId,
+			startedAt: stamp !== null && artifact.suite.hash.startsWith(stamp.suiteHashPrefix) ? stamp.startedAt : null,
+			artifact,
+		});
+	}
+	return { available: true, stored: ids.length, reports, unreadable };
+}

package/src/domains/eval/metrics/aggregate.ts

@@ -0,0 +1,136 @@
+import {
+	EVAL_TRACKED_METRIC_NAMES,
+	type EvalMetricSource,
+	type EvalTrackedMetricName,
+	type EvalVerdictEnvelopeV1,
+} from "../schema/verdict.js";
+
+export interface EvalMetricDistributionV1 {
+	observations: number;
+	measured: number;
+	unmeasured: number;
+	mean: number | null;
+	min: number | null;
+	max: number | null;
+	p90: number | null;
+	variance: number | null;
+	standardDeviation: number | null;
+	sources: EvalMetricSource[];
+}
+
+export type EvalTrackedMetricDistributionsV1 = Record<EvalTrackedMetricName, EvalMetricDistributionV1> & {
+	expectedColdReasons: Record<string, EvalMetricDistributionV1>;
+};
+
+export interface EvalScenarioAggregateV1 {
+	scenarioId: string;
+	trials: number;
+	k: number;
+	passed: number;
+	failed: number;
+	unmeasured: number;
+	machineryFailures: number;
+	passAtK: number;
+	passPowK: number;
+	trackedMetrics: EvalTrackedMetricDistributionsV1;
+}
+
+/** Aggregate each scenario independently so trial outcomes never cross tasks. */
+export function aggregateEvalVerdicts(verdicts: ReadonlyArray<EvalVerdictEnvelopeV1>): EvalScenarioAggregateV1[] {
+	const byScenario = new Map<string, EvalVerdictEnvelopeV1[]>();
+	for (const verdict of verdicts) {
+		const group = byScenario.get(verdict.scenarioId) ?? [];
+		group.push(verdict);
+		byScenario.set(verdict.scenarioId, group);
+	}
+	return [...byScenario.entries()]
+		.sort(([left], [right]) => left.localeCompare(right))
+		.map(([scenarioId, group]) => aggregateScenario(scenarioId, group));
+}
+
+function aggregateScenario(
+	scenarioId: string,
+	verdicts: ReadonlyArray<EvalVerdictEnvelopeV1>,
+): EvalScenarioAggregateV1 {
+	const ordered = [...verdicts].sort((left, right) => left.trialIndex - right.trialIndex);
+	const passed = ordered.filter((verdict) => verdict.outcome === "pass").length;
+	const failed = ordered.filter((verdict) => verdict.outcome === "fail").length;
+	const unmeasured = ordered.filter((verdict) => verdict.outcome === "unmeasured").length;
+	const machineryFailures = ordered.filter((verdict) => verdict.machinery === "infrastructure_failure").length;
+	const fixed = Object.fromEntries(
+		EVAL_TRACKED_METRIC_NAMES.map((name) => [name, distribution(ordered.map((verdict) => verdict.trackedMetrics[name]))]),
+	) as Record<EvalTrackedMetricName, EvalMetricDistributionV1>;
+	const reasons = new Set(ordered.flatMap((verdict) => Object.keys(verdict.trackedMetrics.expectedColdReasons)));
+	const expectedColdReasons = Object.fromEntries(
+		[...reasons]
+			.sort((left, right) => left.localeCompare(right))
+			.map((reason) => [
+				reason,
+				distribution(
+					ordered.map(
+						(verdict) => verdict.trackedMetrics.expectedColdReasons[reason] ?? { value: 0, source: "ledger" as const },
+					),
+				),
+			]),
+	);
+	const k = ordered.length;
+	return {
+		scenarioId,
+		trials: k,
+		k,
+		passed,
+		failed,
+		unmeasured,
+		machineryFailures,
+		passAtK: k > 0 && passed > 0 ? 1 : 0,
+		passPowK: k > 0 && passed === k ? 1 : 0,
+		trackedMetrics: { ...fixed, expectedColdReasons },
+	};
+}
+
+function distribution(
+	metrics: ReadonlyArray<{ value: number | null; source: EvalMetricSource }>,
+): EvalMetricDistributionV1 {
+	const values = metrics.flatMap((metric) => (metric.value === null ? [] : [metric.value]));
+	const sources = [...new Set(metrics.map((metric) => metric.source))].sort(compareSources);
+	if (values.length === 0) {
+		return {
+			observations: metrics.length,
+			measured: 0,
+			unmeasured: metrics.length,
+			mean: null,
+			min: null,
+			max: null,
+			p90: null,
+			variance: null,
+			standardDeviation: null,
+			sources,
+		};
+	}
+	const ordered = [...values].sort((left, right) => left - right);
+	const p90Index = Math.max(0, Math.ceil(ordered.length * 0.9) - 1);
+	const mean = ordered.reduce((sum, value) => sum + value, 0) / ordered.length;
+	const variance = ordered.reduce((sum, value) => sum + (value - mean) ** 2, 0) / ordered.length;
+	return {
+		observations: metrics.length,
+		measured: values.length,
+		unmeasured: metrics.length - values.length,
+		mean,
+		min: ordered[0] ?? null,
+		max: ordered.at(-1) ?? null,
+		p90: ordered[p90Index] ?? null,
+		variance,
+		standardDeviation: Math.sqrt(variance),
+		sources,
+	};
+}
+
+function compareSources(left: EvalMetricSource, right: EvalMetricSource): number {
+	return sourceOrder(left) - sourceOrder(right);
+}
+
+function sourceOrder(source: EvalMetricSource): number {
+	if (source === "ledger") return 0;
+	if (source === "receipt") return 1;
+	return 2;
+}

package/src/domains/eval/metrics/call-ledger-stream.ts

@@ -0,0 +1,112 @@
+import { performance } from "node:perf_hooks";
+import type { SessionEntry } from "../../session/entries.js";
+
+export interface EvalCallLedgerFold {
+	push(chunk: string): void;
+	entries(): SessionEntry[];
+}
+
+/** Fold structured assistant completions into the eval's per-call ledger. */
+export function createEvalCallLedgerFold(now: () => number = () => performance.now()): EvalCallLedgerFold {
+	const entries: SessionEntry[] = [];
+	let pending = "";
+	let activeStartedAt: number | null = null;
+	let activeFirstOutputAt: number | null = null;
+
+	const consume = (line: string): void => {
+		const event = parseRecord(line);
+		if (event === null) return;
+		if (event.type === "message_start" && isAssistantMessage(event.message)) {
+			activeStartedAt = now();
+			activeFirstOutputAt = null;
+			return;
+		}
+		if (event.type === "message_update" && activeStartedAt !== null && activeFirstOutputAt === null) {
+			activeFirstOutputAt = now();
+			return;
+		}
+		if (event.type !== "message_end" || !isAssistantMessage(event.message)) return;
+		const message = event.message;
+		const usage = isRecord(message.usage) ? message.usage : null;
+		if (usage === null) {
+			activeStartedAt = null;
+			activeFirstOutputAt = null;
+			return;
+		}
+		const endedAt = now();
+		const promptCache: Record<string, unknown> = {
+			input: nonNegativeNumber(usage.input) ?? 0,
+			cacheRead: nonNegativeNumber(usage.cacheRead) ?? 0,
+			cacheWrite: nonNegativeNumber(usage.cacheWrite) ?? 0,
+			backendVerdict: "unknown",
+		};
+		if (isRecord(message.backendTimings)) promptCache.backend = structuredClone(message.backendTimings);
+		const previous = entries.at(-1);
+		entries.push({
+			kind: "message",
+			role: "assistant",
+			turnId: `eval-call-${entries.length + 1}`,
+			parentTurnId: previous?.turnId ?? null,
+			timestamp: messageTimestamp(message.timestamp),
+			payload: {
+				promptCache,
+				timing: {
+					ttftMs:
+						activeStartedAt === null ? null : Math.round(Math.max(0, (activeFirstOutputAt ?? endedAt) - activeStartedAt)),
+					apiMs: activeStartedAt === null ? 0 : Math.round(Math.max(0, endedAt - activeStartedAt)),
+				},
+				usage: structuredClone(usage),
+			},
+		});
+		activeStartedAt = null;
+		activeFirstOutputAt = null;
+	};
+
+	return {
+		push(chunk: string): void {
+			pending += chunk;
+			for (;;) {
+				const newline = pending.indexOf("\n");
+				if (newline === -1) break;
+				consume(pending.slice(0, newline).replace(/\r$/u, ""));
+				pending = pending.slice(newline + 1);
+			}
+		},
+		entries(): SessionEntry[] {
+			if (pending.length > 0) {
+				consume(pending.replace(/\r$/u, ""));
+				pending = "";
+			}
+			return structuredClone(entries);
+		},
+	};
+}
+
+function isAssistantMessage(value: unknown): value is Record<string, unknown> & { role: "assistant" } {
+	return isRecord(value) && value.role === "assistant";
+}
+
+function messageTimestamp(value: unknown): string {
+	const milliseconds = nonNegativeNumber(value);
+	if (milliseconds === null) return new Date(0).toISOString();
+	const date = new Date(milliseconds);
+	return Number.isFinite(date.getTime()) ? date.toISOString() : new Date(0).toISOString();
+}
+
+function nonNegativeNumber(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function parseRecord(line: string): Record<string, unknown> | null {
+	if (line.trim().length === 0) return null;
+	try {
+		const value: unknown = JSON.parse(line);
+		return isRecord(value) ? value : null;
+	} catch {
+		return null;
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}