textopt 0.0.0

package/dist/evaluation-OZOp6TB7.cjs

@@ -0,0 +1,598 @@
+//#region src/budget.ts
+/**
+* Rollouts are the currency of prompt optimization: an optimizer's cost is
+* measured in metric calls, not iterations. The engine debits this budget
+* before every evaluation and stops when it can no longer afford the next one.
+*
+* Debiting happens up front, as an atomic reserve-then-refund rather than a
+* check followed by a charge: proposals evaluated concurrently would otherwise
+* each see the same remaining allowance and all spend it.
+*/
+function createBudget(args) {
+	const { maxMetricCalls, spent = 0 } = args;
+	if (!Number.isFinite(maxMetricCalls) || maxMetricCalls <= 0) throw new Error(`maxMetricCalls must be a positive number, received ${maxMetricCalls}`);
+	let used = spent;
+	return {
+		maxMetricCalls,
+		spent: () => used,
+		remaining: () => maxMetricCalls - used,
+		canAfford: (calls) => used + calls <= maxMetricCalls,
+		reserve: (calls) => {
+			if (used + calls > maxMetricCalls) return false;
+			used += calls;
+			return true;
+		},
+		refund: (calls) => {
+			if (calls > used) throw new Error(`Cannot refund ${calls} metric calls; only ${used} are reserved`);
+			used -= calls;
+		}
+	};
+}
+//#endregion
+//#region src/cache.ts
+/**
+* The loop re-evaluates unchanged candidates against the same validation
+* instances constantly (every accepted child inherits most of its parent's
+* text). Caching per (split, candidate text, instance) is the single largest
+* cost saver available, and cached hits are not charged to the metric budget.
+*/
+function evaluationCacheKey(args) {
+	const { hash, instanceId, split, namespace } = args;
+	return `${namespace === void 0 ? split : `${namespace}:${split}`}:${hash}:${instanceId}`;
+}
+/**
+* Identifies a candidate by its text. Hoisted out of the key so a sweep over a
+* thousand validation instances hashes the candidate once instead of a
+* thousand times — the candidate is the long part of the key, the instance id
+* is not.
+*/
+function candidateHash(candidate) {
+	const serialized = Object.keys(candidate).sort().map((name) => `${name}\u0000${candidate[name]}`).join("
");
+	return `${hash32(serialized, 2166136261)}${hash32(serialized, 16777619)}`;
+}
+/**
+* A short, collision-resistant id for arbitrary data, used to name validation
+* instances. Two independent 32-bit passes rather than one: a single pass
+* collides at roughly one pair per thousand instances, and a collision here
+* would silently share cached scores between two different examples.
+*/
+function stableHash(value) {
+	let serialized;
+	try {
+		serialized = JSON.stringify(value) ?? "undefined";
+	} catch {
+		return "";
+	}
+	return `${hash32(serialized, 2166136261)}${hash32(serialized, 16777619)}`;
+}
+function createMemoryCache(args = {}) {
+	const { maxEntries = 1e5, entries: initial = [] } = args;
+	const entries = new Map(initial);
+	return {
+		get: (key) => entries.get(key),
+		set: (key, cached) => {
+			if (entries.size >= maxEntries && !entries.has(key)) {
+				const oldest = entries.keys().next();
+				if (!oldest.done) entries.delete(oldest.value);
+			}
+			entries.set(key, cached);
+		},
+		entries: () => [...entries]
+	};
+}
+function hash32(value, seed) {
+	let hash = seed;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36).padStart(7, "0");
+}
+//#endregion
+//#region src/types.ts
+/**
+* The component names of a candidate, as the union they were inferred from.
+*
+* `Object.keys` widens a closed key union back to `string`. This is the one
+* place that narrowing happens, so every other caller stays assertion-free.
+* Accepts a partial so it also names the components of a component patch.
+*/
+function componentNames(candidate) {
+	return Object.keys(candidate);
+}
+//#endregion
+//#region src/checkpoint.ts
+/**
+* Identifies the run a checkpoint came from: seed candidate, instance ids,
+* seed, and cache namespace.
+*
+* Hashed rather than embedded, because it goes into every snapshot and is only
+* ever compared for equality. The namespace is part of it because a snapshot
+* carries cached scores, and resuming under a different one would replay
+* measurements of a system the run is no longer running. The test set is
+* deliberately absent: it never touches selection, so adding one to a resumed
+* run changes nothing about what that run would have done.
+*/
+function runFingerprint(args) {
+	const { seedCandidate, trainingIds, validationIds, seed, cacheNamespace } = args;
+	return stableHash({
+		seed,
+		seedCandidate: candidateFingerprint(seedCandidate),
+		trainingIds,
+		validationIds,
+		cacheNamespace
+	});
+}
+/**
+* Refuses a checkpoint from a different run rather than silently scoring old
+* candidates against new data — the failure mode that produces a plausible
+* result nobody can reproduce.
+*/
+function assertResumable(args) {
+	const { fingerprint, snapshot } = args;
+	if (snapshot !== void 0 && snapshot.fingerprint !== fingerprint) throw new Error("checkpoint does not belong to this run: the seed candidate, instance ids, seed or cache namespace differ from the ones it was taken with");
+}
+/** A candidate's identity: component names and their text, order-independent. */
+function candidateFingerprint(candidate) {
+	return JSON.stringify(componentNames(candidate).sort().map((name) => [name, candidate[name]]));
+}
+//#endregion
+//#region src/deadline.ts
+/**
+* A wall-clock limit on a run.
+*
+* Rollout and cost ceilings both bound what a run *spends*, and neither bounds
+* how long it takes: a run waiting on a rate-limited provider can sit for an
+* hour without spending a dollar. A deadline is what makes an optimizer safe to
+* put behind a request timeout or a nightly job.
+*
+* Checked between evaluations, so a run overruns by at most the length of one.
+* The clock is injectable because a deadline that can only be tested by waiting
+* is a deadline nobody tests.
+*/
+function createDeadline(args) {
+	const { maxWallClockMs, now = Date.now } = args;
+	const startedAt = now();
+	return {
+		exceeded: () => maxWallClockMs !== void 0 && now() - startedAt >= maxWallClockMs,
+		remainingMs: () => maxWallClockMs === void 0 ? Number.POSITIVE_INFINITY : Math.max(0, maxWallClockMs - (now() - startedAt))
+	};
+}
+//#endregion
+//#region src/evaluation.ts
+const DEFAULT_RETRY = {
+	attempts: 2,
+	delayMs: 500
+};
+/**
+* Raised when a reservation cannot be met mid-flight. A concurrent evaluation
+* cannot check the budget and then spend it — another may take the remainder
+* in between — so running out is reported where it happens and turned into a
+* stop reason by whichever loop is driving.
+*/
+var BudgetExhausted = class extends Error {};
+function createEvaluator(args) {
+	const { adapter, budget, cache, trackOutputs = false, onEvaluation, signal, cacheHits: initialCacheHits = 0, retry, cacheNamespace } = args;
+	const { attempts: retryAttempts, delayMs: retryDelayMs } = {
+		...DEFAULT_RETRY,
+		...retry
+	};
+	let cacheHits = initialCacheHits;
+	let unchargedCalls = 0;
+	const usage = {
+		inputTokens: 0,
+		outputTokens: 0,
+		totalTokens: 0,
+		costUsd: 0,
+		rollouts: 0
+	};
+	/** Folds one adapter call's reported usage into the run's totals. */
+	function recordUsage(args) {
+		usage.rollouts += args.rollouts;
+		for (const rollout of args.evaluation.usage ?? []) addUsage({
+			totals: usage,
+			rollout
+		});
+	}
+	/**
+	* Runs `rows` of `batch`, retrying the instances the adapter reports as
+	* infrastructure failures. Retries are charged like any other rollout —
+	* they cost the same money — but they are never allowed to overdraw: a run
+	* that cannot afford another attempt keeps the transient row instead.
+	*/
+	async function runWithRetries(call) {
+		const { rows } = call;
+		let merged = await runRows(call);
+		let calls = rows.length;
+		for (let attempt = 0; attempt < retryAttempts; attempt += 1) {
+			const failed = transientIndices(merged);
+			if (failed.length === 0 || !affordable({
+				calls: failed.length,
+				charge: call.charge
+			})) return {
+				evaluation: merged,
+				calls
+			};
+			await delay(retryDelayMs * 2 ** attempt);
+			signal?.throwIfAborted();
+			const retried = await runRows({
+				...call,
+				rows: failed.map((index) => rows[index])
+			});
+			calls += failed.length;
+			merged = mergeRows({
+				base: merged,
+				positions: failed,
+				rows: retried
+			});
+		}
+		return {
+			evaluation: merged,
+			calls
+		};
+	}
+	/** One adapter call, charged up front and refunded if it never happened. */
+	async function runRows(call) {
+		const { candidate, rows, captureTraces, charge, ...context } = call;
+		reserve({
+			calls: rows.length,
+			charge
+		});
+		try {
+			const evaluation = await adapter.evaluate({
+				batch: rows,
+				candidate,
+				captureTraces,
+				run: context,
+				signal
+			});
+			assertEvaluation({
+				evaluation,
+				expected: rows.length
+			});
+			recordUsage({
+				evaluation,
+				rollouts: rows.length
+			});
+			return evaluation;
+		} catch (err) {
+			release({
+				calls: rows.length,
+				charge
+			});
+			throw err;
+		}
+	}
+	function affordable(args) {
+		return !args.charge || budget.canAfford(args.calls);
+	}
+	function reserve(args) {
+		if (!args.charge) {
+			unchargedCalls += args.calls;
+			return;
+		}
+		if (!budget.reserve(args.calls)) throw new BudgetExhausted();
+	}
+	function release(args) {
+		if (args.charge) budget.refund(args.calls);
+		else unchargedCalls -= args.calls;
+	}
+	return {
+		countUncached: ({ candidate, ids, split }) => {
+			if (cache === void 0) return ids.length;
+			const hash = candidateHash(candidate);
+			return ids.filter((id) => cache.get(evaluationCacheKey({
+				hash,
+				instanceId: id,
+				split,
+				...cacheNamespace === void 0 ? {} : { namespace: cacheNamespace }
+			})) === void 0).length;
+		},
+		evaluateTraced: async ({ candidate, batch, split, phase, candidateId, iteration }) => {
+			let run;
+			try {
+				run = await runWithRetries({
+					candidate,
+					rows: batch,
+					captureTraces: true,
+					split,
+					phase,
+					candidateId,
+					iteration,
+					charge: true
+				});
+			} catch (err) {
+				if (err instanceof BudgetExhausted) return null;
+				throw err;
+			}
+			onEvaluation?.({
+				iteration,
+				phase,
+				split,
+				candidateId,
+				metricCalls: run.calls,
+				cacheHits: 0,
+				meanScore: measuredMean(run.evaluation) ?? 0
+			});
+			return run.evaluation;
+		},
+		evaluate: async (call) => {
+			const { candidate, batch, ids, split, phase, candidateId, iteration, charge = true } = call;
+			const hash = candidateHash(candidate);
+			const scores = new Array(batch.length);
+			const objectiveScores = new Array(batch.length);
+			const outputs = new Array(batch.length).fill(void 0);
+			const transient = new Array(batch.length).fill(false);
+			const pendingIndices = [];
+			for (let index = 0; index < batch.length; index += 1) {
+				const cached = cache?.get(evaluationCacheKey({
+					hash,
+					instanceId: ids[index],
+					split,
+					...cacheNamespace === void 0 ? {} : { namespace: cacheNamespace }
+				}));
+				if (cached === void 0) pendingIndices.push(index);
+				else {
+					scores[index] = cached.score;
+					objectiveScores[index] = cached.objectiveScores;
+				}
+			}
+			cacheHits += batch.length - pendingIndices.length;
+			let metricCalls = 0;
+			if (pendingIndices.length > 0) {
+				const run = await runWithRetries({
+					candidate,
+					rows: pendingIndices.map((index) => batch[index]),
+					captureTraces: false,
+					split,
+					phase,
+					candidateId,
+					iteration,
+					charge
+				});
+				const evaluation = run.evaluation;
+				metricCalls = run.calls;
+				pendingIndices.forEach((batchIndex, resultIndex) => {
+					const score = evaluation.scores[resultIndex];
+					const objectives = evaluation.objectiveScores?.[resultIndex];
+					scores[batchIndex] = score;
+					objectiveScores[batchIndex] = objectives;
+					if (trackOutputs) outputs[batchIndex] = evaluation.outputs[resultIndex];
+					if (evaluation.transient?.[resultIndex] === true) {
+						transient[batchIndex] = true;
+						return;
+					}
+					cache?.set(evaluationCacheKey({
+						hash,
+						instanceId: ids[batchIndex],
+						split,
+						...cacheNamespace === void 0 ? {} : { namespace: cacheNamespace }
+					}), objectives === void 0 ? { score } : {
+						score,
+						objectiveScores: objectives
+					});
+				});
+			}
+			onEvaluation?.({
+				iteration,
+				phase,
+				split,
+				candidateId,
+				metricCalls,
+				cacheHits: batch.length - pendingIndices.length,
+				meanScore: measuredMean({
+					scores,
+					transient
+				}) ?? 0
+			});
+			return {
+				scores,
+				objectiveScores,
+				outputs,
+				transient
+			};
+		},
+		cacheHits: () => cacheHits,
+		unchargedCalls: () => unchargedCalls,
+		usage: () => ({ ...usage }),
+		entries: () => cache?.entries?.(),
+		restore: (entries) => {
+			for (const [key, cached] of entries) cache?.set(key, cached);
+		}
+	};
+}
+/**
+* A NaN score never raises on its own: every comparison that decides fronts or
+* the best candidate is false for NaN, so the candidate silently becomes an
+* unselectable phantom that still consumed budget. Every other array is read
+* positionally against the batch, so a short one misattributes a diagnosis, an
+* objective or an infrastructure failure to the wrong instance. Catch both at
+* the boundary.
+*/
+function assertEvaluation(args) {
+	const { evaluation, expected } = args;
+	const { scores } = evaluation;
+	const aligned = [
+		["scores", scores],
+		["outputs", evaluation.outputs],
+		["feedback", evaluation.feedback],
+		["objectiveScores", evaluation.objectiveScores],
+		["usage", evaluation.usage],
+		["transient", evaluation.transient]
+	];
+	for (const [name, values] of aligned) if (values !== void 0 && values.length !== expected) throw new Error(`Adapter returned ${values.length} ${name} for a batch of ${expected}; ${name} must align one-to-one with the batch`);
+	for (let index = 0; index < scores.length; index += 1) {
+		const score = scores[index];
+		if (typeof score !== "number" || !Number.isFinite(score)) throw new Error(`Adapter returned a non-finite score at index ${index}: ${String(score)}`);
+	}
+}
+/**
+* Mean over the rows that measured the candidate. Transient rows measured the
+* infrastructure instead, so averaging their zeros in would reject a candidate
+* for an outage; undefined when no row measured anything at all, which is a
+* batch that says nothing rather than a batch that says zero.
+*/
+function measuredMean(batch) {
+	const { scores, transient } = batch;
+	let total = 0;
+	let count = 0;
+	for (let index = 0; index < scores.length; index += 1) {
+		if (transient?.[index] === true) continue;
+		total += scores[index];
+		count += 1;
+	}
+	return count === 0 ? void 0 : total / count;
+}
+/**
+* Whether a run has spent what it was allowed to. Checked between evaluations,
+* because usage is only known once a rollout has been paid for.
+*/
+function costExhausted(args) {
+	return args.maxCostUsd !== void 0 && args.usage.costUsd >= args.maxCostUsd;
+}
+/**
+* The measured mean of an evaluation a run cannot continue without — its seed
+* baseline, and the sweeps it compares everything against.
+*
+* Reporting zero for a batch in which nothing ran would set the search a
+* baseline no rollout produced, and every later comparison would be made
+* against it. Failing here names the provider outage instead.
+*/
+function requireMeasuredMean(args) {
+	const value = measuredMean(args.batch);
+	if (value === void 0) throw new Error(`Every rollout in the ${args.phase} evaluation failed transiently; it measured the infrastructure rather than the candidate`);
+	return value;
+}
+/**
+* Adds one rollout's reading to a running total. `totalTokens` is derived when
+* the provider reports only the two halves, because a caller comparing runs
+* should not have to know which providers report which fields.
+*/
+function addUsage(args) {
+	const { totals, rollout } = args;
+	const { inputTokens = 0, outputTokens = 0, costUsd = 0 } = rollout;
+	totals.inputTokens += inputTokens;
+	totals.outputTokens += outputTokens;
+	totals.totalTokens += rollout.totalTokens ?? inputTokens + outputTokens;
+	totals.costUsd += costUsd;
+}
+function transientIndices(evaluation) {
+	const { transient } = evaluation;
+	if (transient === void 0) return [];
+	const indices = [];
+	for (let index = 0; index < transient.length; index += 1) if (transient[index] === true) indices.push(index);
+	return indices;
+}
+/**
+* Writes a re-run of some rows back over the batch they came from, field by
+* field. Aligned arrays are read positionally everywhere downstream, so a
+* retried row has to land in the position its instance occupies.
+*/
+function mergeRows(args) {
+	const { base, positions, rows } = args;
+	const merged = {
+		outputs: [...base.outputs],
+		scores: [...base.scores],
+		...base.feedback === void 0 ? {} : { feedback: [...base.feedback] },
+		...base.trajectories === void 0 ? {} : { trajectories: [...base.trajectories] },
+		...base.objectiveScores === void 0 ? {} : { objectiveScores: [...base.objectiveScores] },
+		transient: base.transient === void 0 ? [] : [...base.transient]
+	};
+	positions.forEach((position, row) => {
+		merged.outputs[position] = rows.outputs[row];
+		merged.scores[position] = rows.scores[row];
+		if (merged.feedback !== void 0) merged.feedback[position] = rows.feedback?.[row] ?? "";
+		if (merged.trajectories !== void 0 && rows.trajectories !== void 0) merged.trajectories[position] = rows.trajectories[row];
+		if (merged.objectiveScores !== void 0) {
+			const objectives = rows.objectiveScores?.[row];
+			if (objectives !== void 0) merged.objectiveScores[position] = objectives;
+		}
+		merged.transient[position] = rows.transient?.[row] === true;
+	});
+	return merged;
+}
+function delay(milliseconds) {
+	if (milliseconds <= 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		setTimeout(resolve, milliseconds);
+	});
+}
+//#endregion
+Object.defineProperty(exports, "BudgetExhausted", {
+	enumerable: true,
+	get: function() {
+		return BudgetExhausted;
+	}
+});
+Object.defineProperty(exports, "assertResumable", {
+	enumerable: true,
+	get: function() {
+		return assertResumable;
+	}
+});
+Object.defineProperty(exports, "candidateFingerprint", {
+	enumerable: true,
+	get: function() {
+		return candidateFingerprint;
+	}
+});
+Object.defineProperty(exports, "componentNames", {
+	enumerable: true,
+	get: function() {
+		return componentNames;
+	}
+});
+Object.defineProperty(exports, "costExhausted", {
+	enumerable: true,
+	get: function() {
+		return costExhausted;
+	}
+});
+Object.defineProperty(exports, "createBudget", {
+	enumerable: true,
+	get: function() {
+		return createBudget;
+	}
+});
+Object.defineProperty(exports, "createDeadline", {
+	enumerable: true,
+	get: function() {
+		return createDeadline;
+	}
+});
+Object.defineProperty(exports, "createEvaluator", {
+	enumerable: true,
+	get: function() {
+		return createEvaluator;
+	}
+});
+Object.defineProperty(exports, "createMemoryCache", {
+	enumerable: true,
+	get: function() {
+		return createMemoryCache;
+	}
+});
+Object.defineProperty(exports, "measuredMean", {
+	enumerable: true,
+	get: function() {
+		return measuredMean;
+	}
+});
+Object.defineProperty(exports, "requireMeasuredMean", {
+	enumerable: true,
+	get: function() {
+		return requireMeasuredMean;
+	}
+});
+Object.defineProperty(exports, "runFingerprint", {
+	enumerable: true,
+	get: function() {
+		return runFingerprint;
+	}
+});
+Object.defineProperty(exports, "stableHash", {
+	enumerable: true,
+	get: function() {
+		return stableHash;
+	}
+});

package/dist/file-cache.cjs

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+//#region src/file-cache.ts
+/**
+* An evaluation cache that outlives the process, as an append-only log.
+*
+* A long run against a real provider is measured in hours and dollars, and an
+* in-memory cache throws all of it away when the run ends — a crashed run, a
+* re-run with a changed budget, or a second experiment over the same
+* validation set all pay for identical rollouts again.
+*
+* Append-only rather than rewritten: a score is never invalidated (the key
+* names the candidate, the instance, and the environment), and a log survives
+* a process killed mid-write, which a file rewritten in place does not.
+*/
+function createFileCache(args) {
+	const { path, maxEntries = 1e6 } = args;
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(path), { recursive: true });
+	const entries = readLog(path);
+	return {
+		get: (key) => entries.get(key),
+		set: (key, cached) => {
+			if (entries.size >= maxEntries && !entries.has(key)) {
+				const oldest = entries.keys().next();
+				if (!oldest.done) entries.delete(oldest.value);
+			}
+			entries.set(key, cached);
+			(0, node_fs.appendFileSync)(path, `${JSON.stringify([key, cached])}\n`);
+		}
+	};
+}
+/**
+* Later records win, so a re-measured instance replaces its earlier reading.
+* A record that does not parse is dropped rather than fatal: the last line of
+* a log whose process was killed mid-write is routinely half-written, and
+* losing one cached score is not worth failing a run over.
+*/
+function readLog(path) {
+	const entries = /* @__PURE__ */ new Map();
+	let contents;
+	try {
+		contents = (0, node_fs.readFileSync)(path, "utf8");
+	} catch {
+		return entries;
+	}
+	for (const line of contents.split("\n")) {
+		if (line.length === 0) continue;
+		const entry = parseEntry(line);
+		if (entry !== void 0) entries.set(entry[0], entry[1]);
+	}
+	return entries;
+}
+function parseEntry(line) {
+	let parsed;
+	try {
+		parsed = JSON.parse(line);
+	} catch {
+		return;
+	}
+	if (!Array.isArray(parsed) || parsed.length !== 2) return;
+	const [key, cached] = parsed;
+	if (typeof key !== "string" || !isCachedScore(cached)) return;
+	return [key, cached];
+}
+function isCachedScore(value) {
+	return typeof value === "object" && value !== null && typeof value.score === "number";
+}
+//#endregion
+exports.createFileCache = createFileCache;

package/dist/file-cache.d.cts

@@ -0,0 +1,21 @@
+import { n as EvaluationCache } from "./cache-CuSo0NJ8.cjs";
+//#region src/file-cache.d.ts
+/**
+ * An evaluation cache that outlives the process, as an append-only log.
+ *
+ * A long run against a real provider is measured in hours and dollars, and an
+ * in-memory cache throws all of it away when the run ends — a crashed run, a
+ * re-run with a changed budget, or a second experiment over the same
+ * validation set all pay for identical rollouts again.
+ *
+ * Append-only rather than rewritten: a score is never invalidated (the key
+ * names the candidate, the instance, and the environment), and a log survives
+ * a process killed mid-write, which a file rewritten in place does not.
+ */
+declare function createFileCache(args: {
+  path: string;
+  /** Entries kept in memory. The file itself is never trimmed. */
+  maxEntries?: number;
+}): EvaluationCache;
+//#endregion
+export { createFileCache };

package/dist/file-cache.d.mts

@@ -0,0 +1,21 @@
+import { n as EvaluationCache } from "./cache-CuSo0NJ8.mjs";
+//#region src/file-cache.d.ts
+/**
+ * An evaluation cache that outlives the process, as an append-only log.
+ *
+ * A long run against a real provider is measured in hours and dollars, and an
+ * in-memory cache throws all of it away when the run ends — a crashed run, a
+ * re-run with a changed budget, or a second experiment over the same
+ * validation set all pay for identical rollouts again.
+ *
+ * Append-only rather than rewritten: a score is never invalidated (the key
+ * names the candidate, the instance, and the environment), and a log survives
+ * a process killed mid-write, which a file rewritten in place does not.
+ */
+declare function createFileCache(args: {
+  path: string;
+  /** Entries kept in memory. The file itself is never trimmed. */
+  maxEntries?: number;
+}): EvaluationCache;
+//#endregion
+export { createFileCache };