@ls-stack/agent-eval 0.42.3 → 0.45.0

package/dist/{runOrchestration-OVUFw1fL.mjs → runOrchestration-BFdxG9ws.mjs}

@@ -4,8 +4,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { z, z as z$1 } from "zod/v4";
 import dayjs from "dayjs";
 import { Blob as Blob$1, Buffer as Buffer$1, File as File$1 } from "node:buffer";
-import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { getCompositeKey } from "@ls-stack/utils/getCompositeKey";
 import { existsSync } from "node:fs";
@@ -344,7 +344,12 @@ const cacheEntrySchema = z.object({
 	storedAt: z.string(),
 	recording: cacheRecordingSchema
 });
-/** Debug-only raw key metadata stored outside the reusable cache entry. */
+/**
+* Debug-only raw key metadata stored outside the reusable cache entry.
+*
+* Debug entries mirror the serialized cache entry so inspecting one debug file
+* shows both the authored raw key and the persisted payload for that key.
+*/
 const cacheDebugKeyEntrySchema = z.object({
 	version: z.literal(1),
 	key: z.string(),
@@ -352,17 +357,16 @@ const cacheDebugKeyEntrySchema = z.object({
 	operationType: cacheOperationTypeSchema,
 	operationName: z.string(),
 	storedAt: z.string(),
-	rawKey: z.unknown()
+	rawKey: z.unknown(),
+	entry: cacheEntrySchema
 });
 cacheEntrySchema.extend({ debugKey: cacheDebugKeyEntrySchema.optional() });
-/** Persisted per-owner cache file containing multiple cache entries. */
-const cacheFileSchema = z.object({
+z.object({
 	version: z.literal(1),
 	owner: z.string(),
 	entries: z.record(z.string(), cacheEntrySchema)
 });
-/** Persisted per-owner debug file containing raw cache key metadata. */
-const cacheDebugKeyFileSchema = z.object({
+z.object({
 	version: z.literal(1),
 	owner: z.string(),
 	entries: z.record(z.string(), cacheDebugKeyEntrySchema)
@@ -4176,7 +4180,7 @@ function createTraceCache(generateSpanId) {
 		if (!scope) return await fn();
 		const cacheCtx = scope.cacheContext;
 		if (cacheCtx === void 0 || scope.replayingDepth > 0) return await fn();
-		const namespace = info.namespace ?? `${cacheCtx.evalId}__${info.name}`;
+		const namespace = info.namespace ?? `${cacheCtx.evalId}.${info.name}`;
 		const keyHash = await hashCacheKey({
 			namespace,
 			key: info.key
@@ -4835,12 +4839,14 @@ const cacheSerializationMarker = "__aecs";
 const supportedCacheSerializationPrefix = "v1:";
 const externalJsonCacheSerializationMarker = "v1:ExternalJson";
 const externalJsonBlobExtension = ".json.br";
+const cacheEntryExtension = ".json.br";
+const debugEntryExtension = ".json";
 /**
 * Create a filesystem-backed cache adapter rooted at `<workspaceRoot>/<dir>`.
 *
-* Cache entries are grouped into one inspectable JSON file per cache owner.
-* Writes use a short-lived lock directory plus `<name>.tmp` + atomic
-* `rename` to avoid partial reads and lost updates under concurrent access.
+* Cache entries are stored as one Brotli-compressed JSON file per entry, nested
+* under a sanitized namespace directory. Debug sidecars mirror one key per file
+* and include the authored raw key plus the serialized cache entry.
 */
 function createFsCacheStore(options) {
 	const cacheDir = resolve(options.workspaceRoot, options.dir ?? ".agent-evals/cache");
@@ -4860,76 +4866,64 @@ function createFsCacheStore(options) {
 			return blobDir;
 		},
 		async lookup(namespace, keyHash) {
-			const entry = (await readCacheFile(cacheDir, ownerFromNamespace(namespace)))?.entries[keyHash] ?? null;
+			const entry = await readCacheEntry(cacheDir, namespace, keyHash);
 			return entry === null ? null : await materializeExternalJsonCacheEntry(entry, externalJsonStore);
 		},
 		async lookupWithDebug(namespace, keyHash) {
-			const owner = ownerFromNamespace(namespace);
-			const rawEntry = (await readCacheFile(cacheDir, owner))?.entries[keyHash] ?? null;
-			const entry = rawEntry === null ? null : await materializeExternalJsonCacheEntry(rawEntry, externalJsonStore);
-			if (entry === null) return null;
-			const debugKey = (await readDebugKeyFile(debugDir, owner))?.entries[keyHash];
+			const rawEntry = await readCacheEntry(cacheDir, namespace, keyHash);
+			if (rawEntry === null) return null;
+			const entry = await materializeExternalJsonCacheEntry(rawEntry, externalJsonStore);
+			const debugKey = await readDebugEntry(debugDir, namespace, keyHash);
 			const deserializedEntry = {
 				...entry,
 				recording: deserializeCacheRecording(entry.recording)
 			};
-			return debugKey === void 0 ? deserializedEntry : {
+			return debugKey === null ? deserializedEntry : {
 				...deserializedEntry,
 				debugKey
 			};
 		},
 		async write(entry, debugKey) {
-			const owner = ownerFromNamespace(entry.namespace);
-			const filePath = ownerPath(cacheDir, owner);
-			await mkdir(cacheDir, { recursive: true });
-			await withCacheFileLock(filePath, async () => {
-				await writeCacheFile(cacheDir, {
-					version: 1,
-					owner,
-					entries: pruneEntries({
-						...(await readCacheFile(cacheDir, owner))?.entries ?? {},
-						[entry.key]: entry
-					}, entry.namespace, maxEntriesForNamespace(entry.namespace, defaultMaxEntries, options.maxEntriesByNamespace), entry.key)
-				});
-			});
-			await pruneExternalJsonBlobs(cacheDir, blobDir);
+			const maxEntries = maxEntriesForNamespace(entry.namespace, defaultMaxEntries, options.maxEntriesByNamespace);
+			await withCacheFileLock(namespaceLockPath(cacheDir, entry.namespace), () => writeCompressedCacheEntry(cacheDir, entry));
 			if (debugKey !== void 0) {
 				if ((await resultify(() => writeDebugKeyEntry({
 					debugDir,
 					entry,
-					debugKey,
-					maxEntries: maxEntriesForNamespace(entry.namespace, defaultMaxEntries, options.maxEntriesByNamespace)
+					debugKey
 				}))).error) await resultify(() => clearDebugEntries(debugDir, {
 					namespace: entry.namespace,
 					key: entry.key
 				}));
 			}
+			await pruneEntriesForNamespace({
+				cacheDir,
+				debugDir,
+				namespace: entry.namespace,
+				maxEntries,
+				protectedKey: entry.key
+			});
+			await pruneExternalJsonBlobs(cacheDir, blobDir);
 		},
 		async list() {
-			if (!existsSync(cacheDir)) return [];
-			const files = await readdir(cacheDir);
+			const files = await listCacheEntryFiles(cacheDir);
 			const items = [];
-			for (const fileName of files) {
-				if (!fileName.endsWith(".json")) continue;
-				const filePath = join(cacheDir, fileName);
-				const fileStatResult = await resultify(() => stat(filePath));
-				if (fileStatResult.error || !fileStatResult.value.isFile()) continue;
-				const cacheFile = await readCacheFilePath(filePath);
-				if (cacheFile === null) continue;
-				for (const entry of Object.values(cacheFile.entries)) {
-					const operationType = entry.operationType ?? "span";
-					const operationName = entry.operationName ?? entry.spanName ?? entry.namespace;
-					items.push({
-						key: entry.key,
-						namespace: entry.namespace,
-						operationType,
-						operationName,
-						spanName: entry.spanName,
-						spanKind: entry.spanKind,
-						storedAt: entry.storedAt,
-						sizeBytes: Buffer.byteLength(JSON.stringify(entry), "utf8")
-					});
-				}
+			for (const filePath of files) {
+				const fileEntry = await readCacheEntryFilePath(filePath);
+				if (fileEntry === null || !entryMatchesPath(filePath, fileEntry.entry)) continue;
+				const entry = fileEntry.entry;
+				const operationType = entry.operationType ?? "span";
+				const operationName = entry.operationName ?? entry.spanName ?? entry.namespace;
+				items.push({
+					key: entry.key,
+					namespace: entry.namespace,
+					operationType,
+					operationName,
+					spanName: entry.spanName,
+					spanKind: entry.spanKind,
+					storedAt: entry.storedAt,
+					sizeBytes: fileEntry.sizeBytes
+				});
 			}
 			items.sort((a, b) => a.storedAt < b.storedAt ? 1 : -1);
 			return items;
@@ -4951,41 +4945,12 @@ function createFsCacheStore(options) {
 				return;
 			}
 			if (filter.namespace !== void 0) {
-				const owner = ownerFromNamespace(filter.namespace);
-				const filePath = ownerPath(cacheDir, owner);
-				if (existsSync(cacheDir)) await withCacheFileLock(filePath, async () => {
-					const cacheFile = await readCacheFile(cacheDir, owner);
-					if (cacheFile === null) return;
-					await writeOrRemoveCacheFile(cacheDir, {
-						version: 1,
-						owner,
-						entries: Object.fromEntries(Object.entries(cacheFile.entries).filter(([key, entry]) => {
-							if (filter.key !== void 0) return key !== filter.key;
-							return entry.namespace !== filter.namespace;
-						}))
-					});
-				});
+				await clearCacheEntries(cacheDir, filter);
 				await clearDebugEntries(debugDir, filter);
 				await pruneExternalJsonBlobs(cacheDir, blobDir);
 				return;
 			}
-			if (existsSync(cacheDir)) {
-				const files = await readdir(cacheDir);
-				for (const fileName of files) {
-					if (!fileName.endsWith(".json")) continue;
-					const filePath = join(cacheDir, fileName);
-					await withCacheFileLock(filePath, async () => {
-						const cacheFile = await readCacheFilePath(filePath);
-						if (cacheFile === null) return;
-						const entries = Object.fromEntries(Object.entries(cacheFile.entries).filter(([key]) => key !== filter.key));
-						await writeOrRemoveCacheFile(cacheDir, {
-							version: 1,
-							owner: cacheFile.owner,
-							entries
-						});
-					});
-				}
-			}
+			await clearCacheEntries(cacheDir, filter);
 			await clearDebugEntries(debugDir, filter);
 			await pruneExternalJsonBlobs(cacheDir, blobDir);
 		}
@@ -5030,19 +4995,185 @@ function maxEntriesForNamespace(namespace, defaultMaxEntries, maxEntriesByNamesp
 	const namespaceMaxEntries = maxEntriesByNamespace?.[namespace];
 	return namespaceMaxEntries === void 0 ? defaultMaxEntries : normalizeMaxEntries(namespaceMaxEntries, defaultMaxEntries);
 }
-function ownerFromNamespace(namespace) {
-	const [owner] = namespace.split("__");
-	return owner === void 0 || owner.length === 0 ? namespace : owner;
-}
-function ownerPath(cacheDir, owner) {
-	return join(cacheDir, `${sanitizeSegment$1(owner)}.json`);
-}
 function toPendingKey(namespace, keyHash) {
 	return `${namespace}::${keyHash}`;
 }
 function sanitizeSegment$1(segment) {
 	return segment.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
+function namespaceDirPath(rootDir, namespace) {
+	return join(rootDir, sanitizeSegment$1(namespace));
+}
+function namespaceLockPath(rootDir, namespace) {
+	return join(rootDir, `${sanitizeSegment$1(namespace)}.namespace`);
+}
+function cacheEntryPath(cacheDir, namespace, key) {
+	return entryPath({
+		rootDir: cacheDir,
+		namespace,
+		key,
+		extension: cacheEntryExtension
+	});
+}
+function debugEntryPath(debugDir, namespace, key) {
+	return entryPath({
+		rootDir: debugDir,
+		namespace,
+		key,
+		extension: debugEntryExtension
+	});
+}
+function entryPath(params) {
+	const namespaceDir = resolve(namespaceDirPath(params.rootDir, params.namespace));
+	const filePath = resolve(namespaceDir, `${params.key}${params.extension}`);
+	if (filePath !== namespaceDir && !filePath.startsWith(`${namespaceDir}${sep}`)) throw new Error(`Cache entry key escapes namespace directory: ${params.key}`);
+	return filePath;
+}
+async function readCacheEntry(cacheDir, namespace, key) {
+	return (await readCacheEntryFilePath(cacheEntryPath(cacheDir, namespace, key), {
+		namespace,
+		key
+	}))?.entry ?? null;
+}
+async function readCacheEntryFilePath(filePath, expected) {
+	if (!existsSync(filePath)) return null;
+	const compressedResult = await resultify(() => readFile(filePath));
+	if (compressedResult.error) return null;
+	const rawResult = resultify(() => brotliDecompressSync(compressedResult.value).toString("utf8"));
+	if (rawResult.error) return null;
+	const json = safeJsonParse(rawResult.value);
+	if (json === null) return null;
+	const parsed = cacheEntrySchema.safeParse(json);
+	if (!parsed.success) return null;
+	const entry = parsed.data;
+	if (!usesSupportedCacheSerialization(entry.recording)) return null;
+	if (expected !== void 0 && (entry.namespace !== expected.namespace || entry.key !== expected.key)) return null;
+	return {
+		entry,
+		sizeBytes: compressedResult.value.byteLength
+	};
+}
+async function writeCompressedCacheEntry(cacheDir, entry) {
+	const filePath = cacheEntryPath(cacheDir, entry.namespace, entry.key);
+	const rawJson = JSON.stringify(entry);
+	await writeAtomicFile(filePath, brotliCompressSync(Buffer.from(rawJson, "utf8")));
+}
+async function readDebugEntry(debugDir, namespace, key) {
+	return readDebugEntryFilePath(debugEntryPath(debugDir, namespace, key), {
+		namespace,
+		key
+	});
+}
+async function readDebugEntryFilePath(filePath, expected) {
+	if (!existsSync(filePath)) return null;
+	const rawResult = await resultify(() => readFile(filePath, "utf8"));
+	if (rawResult.error) return null;
+	const json = safeJsonParse(rawResult.value);
+	if (json === null) return null;
+	const parsed = cacheDebugKeyEntrySchema.safeParse(json);
+	if (!parsed.success) return null;
+	const entry = parsed.data;
+	if (entry.entry.namespace !== entry.namespace || entry.entry.key !== entry.key || !usesSupportedCacheSerialization(entry.entry.recording)) return null;
+	if (expected !== void 0 && (entry.namespace !== expected.namespace || entry.key !== expected.key)) return null;
+	return entry;
+}
+async function writeDebugKeyEntry(params) {
+	const { debugDir, entry, debugKey } = params;
+	const debugEntry = {
+		version: 1,
+		key: entry.key,
+		namespace: entry.namespace,
+		operationType: debugKey.operationType,
+		operationName: debugKey.operationName,
+		storedAt: entry.storedAt,
+		rawKey: debugKey.rawKey,
+		entry
+	};
+	await withCacheFileLock(namespaceLockPath(debugDir, entry.namespace), () => writePrettyDebugEntry(debugDir, debugEntry));
+}
+async function writePrettyDebugEntry(debugDir, entry) {
+	await writeAtomicFile(debugEntryPath(debugDir, entry.namespace, entry.key), JSON.stringify(entry, null, 2));
+}
+async function writeAtomicFile(filePath, contents) {
+	await mkdir(dirname(filePath), { recursive: true });
+	const tmpPath = `${filePath}.${process.pid.toString()}.${randomUUID()}.tmp`;
+	await writeFile(tmpPath, contents);
+	await rename(tmpPath, filePath);
+}
+async function clearCacheEntries(cacheDir, filter) {
+	const files = filter.namespace === void 0 ? await listCacheEntryFiles(cacheDir) : await listCacheEntryFiles(namespaceDirPath(cacheDir, filter.namespace));
+	for (const filePath of files) {
+		const fileEntry = await readCacheEntryFilePath(filePath);
+		if (fileEntry === null) continue;
+		const entry = fileEntry.entry;
+		if (!entryMatchesFilter(entry, filter)) continue;
+		await withCacheFileLock(namespaceLockPath(cacheDir, entry.namespace), () => rm(filePath, { force: true }));
+	}
+	if (filter.namespace !== void 0) await removeDirIfEmpty(namespaceDirPath(cacheDir, filter.namespace));
+}
+async function clearDebugEntries(debugDir, filter) {
+	const files = filter.namespace === void 0 ? await listDebugEntryFiles(debugDir) : await listDebugEntryFiles(namespaceDirPath(debugDir, filter.namespace));
+	for (const filePath of files) {
+		const entry = await readDebugEntryFilePath(filePath);
+		if (entry === null || !entryMatchesFilter(entry, filter)) continue;
+		await withCacheFileLock(namespaceLockPath(debugDir, entry.namespace), () => rm(filePath, { force: true }));
+	}
+	if (filter.namespace !== void 0) await removeDirIfEmpty(namespaceDirPath(debugDir, filter.namespace));
+}
+function entryMatchesFilter(entry, filter) {
+	if (filter.namespace !== void 0 && entry.namespace !== filter.namespace) return false;
+	return filter.key === void 0 || entry.key === filter.key;
+}
+async function pruneEntriesForNamespace(params) {
+	const { cacheDir, debugDir, namespace, maxEntries, protectedKey } = params;
+	await withCacheFileLock(namespaceLockPath(cacheDir, namespace), async () => {
+		const keptKeys = await pruneCacheEntriesForNamespace(cacheDir, namespace, maxEntries, protectedKey);
+		await withCacheFileLock(namespaceLockPath(debugDir, namespace), () => pruneDebugEntriesForNamespace(debugDir, namespace, keptKeys));
+	});
+}
+async function pruneCacheEntriesForNamespace(cacheDir, namespace, maxEntries, protectedKey) {
+	const entries = await listCacheEntriesForNamespace(cacheDir, namespace);
+	const sorted = entries.toSorted((a, b) => a.entry.storedAt < b.entry.storedAt ? 1 : -1);
+	const keptKeys = /* @__PURE__ */ new Set();
+	const protectedEntry = entries.find((item) => item.entry.key === protectedKey);
+	if (protectedEntry !== void 0) keptKeys.add(protectedEntry.entry.key);
+	for (const item of sorted) {
+		if (keptKeys.size >= maxEntries) break;
+		keptKeys.add(item.entry.key);
+	}
+	for (const item of entries) if (!keptKeys.has(item.entry.key)) await rm(item.filePath, { force: true });
+	await removeDirIfEmpty(namespaceDirPath(cacheDir, namespace));
+	return keptKeys;
+}
+async function pruneDebugEntriesForNamespace(debugDir, namespace, keptKeys) {
+	const files = await listDebugEntryFiles(namespaceDirPath(debugDir, namespace));
+	for (const filePath of files) {
+		const entry = await readDebugEntryFilePath(filePath);
+		if (entry !== null && entry.namespace === namespace && !keptKeys.has(entry.key)) await rm(filePath, { force: true });
+	}
+	await removeDirIfEmpty(namespaceDirPath(debugDir, namespace));
+}
+async function listCacheEntriesForNamespace(cacheDir, namespace) {
+	const files = await listCacheEntryFiles(namespaceDirPath(cacheDir, namespace));
+	const entries = [];
+	for (const filePath of files) {
+		const fileEntry = await readCacheEntryFilePath(filePath);
+		if (fileEntry !== null && fileEntry.entry.namespace === namespace && entryMatchesPath(filePath, fileEntry.entry)) entries.push({
+			filePath,
+			entry: fileEntry.entry
+		});
+	}
+	return entries;
+}
+function entryMatchesPath(filePath, entry) {
+	return basename(filePath) === `${entry.key}${cacheEntryExtension}` && basename(dirname(filePath)) === sanitizeSegment$1(entry.namespace);
+}
+function usesSupportedCacheSerialization(value) {
+	if (Array.isArray(value)) return value.every(usesSupportedCacheSerialization);
+	if (!isRecordLike(value)) return true;
+	if (Object.hasOwn(value, cacheSerializationMarker) && (typeof value[cacheSerializationMarker] !== "string" || !value[cacheSerializationMarker].startsWith(supportedCacheSerializationPrefix))) return false;
+	return Object.values(value).every(usesSupportedCacheSerialization);
+}
 function createExternalJsonBlobStore(blobDir) {
 	return {
 		async write(rawJson) {
@@ -5051,12 +5182,7 @@ function createExternalJsonBlobStore(blobDir) {
 			const path = externalJsonBlobPath(hash);
 			const compressed = brotliCompressSync(rawBytes);
 			const filePath = resolveStorePath(blobDir, path);
-			if (!existsSync(filePath)) {
-				await mkdir(dirname(filePath), { recursive: true });
-				const tmpPath = `${filePath}.${process.pid.toString()}.tmp`;
-				await writeFile(tmpPath, compressed);
-				await rename(tmpPath, filePath);
-			}
+			if (!existsSync(filePath)) await writeAtomicFile(filePath, compressed);
 			return {
 				compressedLength: compressed.byteLength,
 				hash,
@@ -5097,13 +5223,10 @@ async function pruneExternalJsonBlobs(cacheDir, blobDir) {
 }
 async function collectReferencedExternalJsonBlobPaths(cacheDir) {
 	const paths = /* @__PURE__ */ new Set();
-	if (!existsSync(cacheDir)) return paths;
-	const files = await readdir(cacheDir);
-	for (const fileName of files) {
-		if (!fileName.endsWith(".json")) continue;
-		const cacheFile = await readCacheFilePath(join(cacheDir, fileName));
-		if (cacheFile === null) continue;
-		collectExternalJsonBlobPaths(cacheFile, paths);
+	for (const filePath of await listCacheEntryFiles(cacheDir)) {
+		const fileEntry = await readCacheEntryFilePath(filePath);
+		if (fileEntry === null || !entryMatchesPath(filePath, fileEntry.entry)) continue;
+		collectExternalJsonBlobPaths(fileEntry.entry, paths);
 	}
 	return paths;
 }
@@ -5122,8 +5245,9 @@ async function listExternalJsonBlobPaths(blobDir) {
 	return paths;
 }
 async function collectExternalJsonBlobFilePaths(root, dir, paths) {
-	const entries = await readdir(dir, { withFileTypes: true });
-	for (const entry of entries) {
+	const entriesResult = await resultify(() => readdir(dir, { withFileTypes: true }));
+	if (entriesResult.error) return;
+	for (const entry of entriesResult.value) {
 		const path = join(dir, entry.name);
 		if (entry.isDirectory()) {
 			await collectExternalJsonBlobFilePaths(root, path, paths);
@@ -5132,153 +5256,38 @@ async function collectExternalJsonBlobFilePaths(root, dir, paths) {
 		if (entry.isFile() && entry.name.endsWith(externalJsonBlobExtension)) paths.push(relative(root, path));
 	}
 }
-async function readCacheFile(cacheDir, owner) {
-	return readCacheFilePath(ownerPath(cacheDir, owner));
+async function listCacheEntryFiles(rootDir) {
+	return listFilesWithExtension(rootDir, cacheEntryExtension);
 }
-async function readCacheFilePath(filePath) {
-	if (!existsSync(filePath)) return null;
-	const rawResult = await resultify(() => readFile(filePath, "utf-8"));
-	if (rawResult.error) return null;
-	const json = safeJsonParse(rawResult.value);
-	if (json === null) return null;
-	const parsed = cacheFileSchema.safeParse(json);
-	if (!parsed.success) return null;
-	return {
-		...parsed.data,
-		entries: Object.fromEntries(Object.entries(parsed.data.entries).filter(([, entry]) => usesSupportedCacheSerialization(entry.recording)))
-	};
-}
-function usesSupportedCacheSerialization(value) {
-	if (Array.isArray(value)) return value.every(usesSupportedCacheSerialization);
-	if (!isRecordLike(value)) return true;
-	if (Object.hasOwn(value, cacheSerializationMarker) && (typeof value[cacheSerializationMarker] !== "string" || !value[cacheSerializationMarker].startsWith(supportedCacheSerializationPrefix))) return false;
-	return Object.values(value).every(usesSupportedCacheSerialization);
+async function listDebugEntryFiles(rootDir) {
+	return listFilesWithExtension(rootDir, debugEntryExtension);
 }
-async function writeOrRemoveCacheFile(cacheDir, cacheFile) {
-	if (Object.keys(cacheFile.entries).length === 0) {
-		await rm(ownerPath(cacheDir, cacheFile.owner), { force: true });
-		return;
+async function listFilesWithExtension(rootDir, extension) {
+	if (!existsSync(rootDir)) return [];
+	const entriesResult = await resultify(() => readdir(rootDir, { withFileTypes: true }));
+	if (entriesResult.error) return [];
+	const files = [];
+	for (const entry of entriesResult.value) {
+		const filePath = join(rootDir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await listFilesWithExtension(filePath, extension));
+			continue;
+		}
+		if (entry.isFile() && entry.name.endsWith(extension)) files.push(filePath);
 	}
-	await writeCacheFile(cacheDir, cacheFile);
-}
-async function writeCacheFile(cacheDir, cacheFile) {
-	await mkdir(cacheDir, { recursive: true });
-	const filePath = ownerPath(cacheDir, cacheFile.owner);
-	const tmpPath = `${filePath}.${process.pid.toString()}.tmp`;
-	await writeFile(tmpPath, JSON.stringify(cacheFile, null, 2));
-	await rename(tmpPath, filePath);
-}
-async function readDebugKeyFile(debugDir, owner) {
-	return readDebugKeyFilePath(ownerPath(debugDir, owner));
+	return files;
 }
-async function readDebugKeyFilePath(filePath) {
-	if (!existsSync(filePath)) return null;
-	const rawResult = await resultify(() => readFile(filePath, "utf-8"));
-	if (rawResult.error) return null;
-	const json = safeJsonParse(rawResult.value);
-	if (json === null) return null;
-	const parsed = cacheDebugKeyFileSchema.safeParse(json);
-	if (!parsed.success) return null;
-	return parsed.data;
-}
-async function writeDebugKeyEntry(params) {
-	const { debugDir, entry, debugKey, maxEntries } = params;
-	const owner = ownerFromNamespace(entry.namespace);
-	const filePath = ownerPath(debugDir, owner);
-	await mkdir(debugDir, { recursive: true });
-	await withCacheFileLock(filePath, async () => {
-		const entries = (await readDebugKeyFile(debugDir, owner))?.entries ?? {};
-		const debugEntry = {
-			version: 1,
-			key: entry.key,
-			namespace: entry.namespace,
-			operationType: debugKey.operationType,
-			operationName: debugKey.operationName,
-			storedAt: entry.storedAt,
-			rawKey: debugKey.rawKey
-		};
-		await writeDebugKeyFile(debugDir, {
-			version: 1,
-			owner,
-			entries: pruneDebugKeyEntries({
-				...entries,
-				[entry.key]: debugEntry
-			}, entry.namespace, maxEntries, entry.key)
-		});
+async function removeDirIfEmpty(dirPath) {
+	const entriesResult = await resultify(() => readdir(dirPath));
+	if (entriesResult.error || entriesResult.value.length > 0) return;
+	await rm(dirPath, {
+		recursive: true,
+		force: true
 	});
 }
-async function clearDebugEntries(debugDir, filter) {
-	if (!existsSync(debugDir)) return;
-	if (filter.namespace !== void 0) {
-		const owner = ownerFromNamespace(filter.namespace);
-		await withCacheFileLock(ownerPath(debugDir, owner), async () => {
-			const debugFile = await readDebugKeyFile(debugDir, owner);
-			if (debugFile === null) return;
-			await writeOrRemoveDebugKeyFile(debugDir, {
-				version: 1,
-				owner,
-				entries: Object.fromEntries(Object.entries(debugFile.entries).filter(([key, entry]) => {
-					if (filter.key !== void 0) return key !== filter.key;
-					return entry.namespace !== filter.namespace;
-				}))
-			});
-		});
-		return;
-	}
-	const files = await readdir(debugDir);
-	for (const fileName of files) {
-		if (!fileName.endsWith(".json")) continue;
-		const filePath = join(debugDir, fileName);
-		await withCacheFileLock(filePath, async () => {
-			const debugFile = await readDebugKeyFilePath(filePath);
-			if (debugFile === null) return;
-			const entries = Object.fromEntries(Object.entries(debugFile.entries).filter(([key]) => key !== filter.key));
-			await writeOrRemoveDebugKeyFile(debugDir, {
-				version: 1,
-				owner: debugFile.owner,
-				entries
-			});
-		});
-	}
-}
-async function writeOrRemoveDebugKeyFile(debugDir, debugFile) {
-	if (Object.keys(debugFile.entries).length === 0) {
-		await rm(ownerPath(debugDir, debugFile.owner), { force: true });
-		return;
-	}
-	await writeDebugKeyFile(debugDir, debugFile);
-}
-async function writeDebugKeyFile(debugDir, debugFile) {
-	await mkdir(debugDir, { recursive: true });
-	const filePath = ownerPath(debugDir, debugFile.owner);
-	const tmpPath = `${filePath}.${process.pid.toString()}.tmp`;
-	await writeFile(tmpPath, JSON.stringify(debugFile, null, 2));
-	await rename(tmpPath, filePath);
-}
-function pruneEntries(entries, namespace, maxEntries, protectedKey) {
-	const sorted = Object.values(entries).filter((entry) => entry.namespace === namespace).toSorted((a, b) => a.storedAt < b.storedAt ? 1 : -1);
-	const kept = /* @__PURE__ */ new Map();
-	const protectedEntry = entries[protectedKey];
-	if (protectedEntry?.namespace === namespace) kept.set(protectedEntry.key, protectedEntry);
-	for (const entry of sorted) {
-		if (kept.size >= maxEntries) break;
-		kept.set(entry.key, entry);
-	}
-	return Object.fromEntries(Object.values(entries).filter((entry) => entry.namespace !== namespace || kept.has(entry.key)).toSorted((a, b) => a.key < b.key ? -1 : 1).map((entry) => [entry.key, entry]));
-}
-function pruneDebugKeyEntries(entries, namespace, maxEntries, protectedKey) {
-	const sorted = Object.values(entries).filter((entry) => entry.namespace === namespace).toSorted((a, b) => a.storedAt < b.storedAt ? 1 : -1);
-	const kept = /* @__PURE__ */ new Map();
-	const protectedEntry = entries[protectedKey];
-	if (protectedEntry?.namespace === namespace) kept.set(protectedEntry.key, protectedEntry);
-	for (const entry of sorted) {
-		if (kept.size >= maxEntries) break;
-		kept.set(entry.key, entry);
-	}
-	return Object.fromEntries(Object.values(entries).filter((entry) => entry.namespace !== namespace || kept.has(entry.key)).toSorted((a, b) => a.key < b.key ? -1 : 1).map((entry) => [entry.key, entry]));
-}
 async function withCacheFileLock(filePath, fn) {
 	const lockPath = `${filePath}.lock`;
+	await mkdir(dirname(lockPath), { recursive: true });
 	await acquireLock(lockPath);
 	const result = await resultify(fn);
 	await rm(lockPath, {

package/dist/{runner-BJQq7cpd.mjs → runner--aH0jO4Z.mjs}

@@ -1,2 +1,2 @@
-import { n as initRunner, t as getRunnerInstance } from "./runner-B1KygirW.mjs";
+import { n as initRunner, t as getRunnerInstance } from "./runner-DJWn_7p0.mjs";
 export { getRunnerInstance, initRunner };

package/dist/{runner-B1KygirW.mjs → runner-DJWn_7p0.mjs}

@@ -1,5 +1,5 @@
-import { n as createRunner } from "./cli-BeJCJMQo.mjs";
-import "./src-D7_xKo7h.mjs";
+import { n as createRunner } from "./cli-vdJYkEVk.mjs";
+import "./src-BRqs3kSA.mjs";
 //#region ../../apps/server/src/runner.ts
 let runnerInstance = null;
 function getRunnerInstance() {

package/dist/{src-D7_xKo7h.mjs → src-BRqs3kSA.mjs}

@@ -1,5 +1,5 @@
-import { It as defineEval$1, rt as matchesEvalTags$1 } from "./runOrchestration-OVUFw1fL.mjs";
-import "./cli-BeJCJMQo.mjs";
+import { It as defineEval$1, rt as matchesEvalTags$1 } from "./runOrchestration-BFdxG9ws.mjs";
+import "./cli-vdJYkEVk.mjs";
 //#region src/index.ts
 /** Register an eval definition with typed tag support. */
 function defineEval(definition) {