spiracha 1.3.3 → 1.5.0

package/apps/ui/dist/server/assets/{codex-server-DIYFLozB.js → codex-server-CGXU4H8-.js}

@@ -1,16 +1,20 @@
 import { t as createServerFn } from "../server.js";
-import { t as createServerRpc } from "./createServerRpc-Cg-Zr1rq.js";
-import { a as cleanInlineTitle, c as formatInlineLiteral, d as readJsonlObjects, h as renderSection, i as cleanExtractedText, l as formatModelLabel, m as renderMetadataBlock, n as asObject, o as createExportWriteStream, p as renderDocumentTitle, r as asString, s as finalizeExportWriteStream, t as asNumber, u as getPortablePathBasename } from "./shared-CPRNYIql.js";
+import { t as createServerRpc } from "./createServerRpc-CF_DEwnm.js";
+import { a as sanitizeExportFileName, n as ensureUiExportDir, o as zipExportDirectory, r as getExportMimeType, s as zipExportFile, t as buildUiExportDownloadUrl } from "./ui-export-files-BHLX9bhN.js";
+import { a as cleanExtractedText, c as finalizeExportWriteStream, d as getPortablePathBasename, f as readJsonlObjects$1, g as renderSection, h as renderMetadataBlock, i as asString, l as formatInlineLiteral, m as renderDocumentTitle, n as asNumber, o as cleanInlineTitle, r as asObject, s as createExportWriteStream, u as formatModelLabel } from "./shared-DyhChtHf.js";
+import { t as mapWithConcurrency } from "./concurrency-VXtYvlGh.js";
 import { t as isRetryableSqliteError } from "./sqlite-error-LZDrnxdd.js";
 import { t as applyPathTransforms } from "./path-transforms-DL2IwtYd.js";
 import { finished } from "node:stream/promises";
 import { z } from "zod";
-import { Database } from "bun:sqlite";
+import { createHash, randomUUID } from "node:crypto";
 import { copyFile, mkdir, mkdtemp, readdir, rename, rm, stat, utimes } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createReadStream } from "node:fs";
-import { createHash, randomUUID } from "node:crypto";
+import { Database, constants } from "bun:sqlite";
+import { closeSync, createReadStream, openSync, readSync, readdirSync, statSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { pathToFileURL } from "node:url";
 //#region ../../src/lib/codex-exporter-types.ts
 var DEFAULT_CODEX_DIR = path.join(os.homedir(), ".codex");
 var DEFAULT_DB_PATH = path.join(DEFAULT_CODEX_DIR, "state_5.sqlite");
@@ -55,7 +59,7 @@ var parseCodexTranscriptFile = async (sessionFile, options = {}) => {
 	const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
 	const maxTurnContexts = options.maxTurnContexts ?? Number.POSITIVE_INFINITY;
 	let sequence = 0;
-	for await (const parsed of readJsonlObjects(sessionFile)) {
+	for await (const parsed of readJsonlObjects$1(sessionFile)) {
 		captureSessionMeta$1(parsed, sessionMeta);
 		if (asString(parsed.type) === "turn_context") {
 			if (turnContexts.length < maxTurnContexts) captureTurnContext(parsed, turnContexts);
@@ -373,6 +377,16 @@ var toCachePath = (key) => {
 var hashCacheKeyParts = (...parts) => {
 	return createHash("sha1").update(parts.join("|")).digest("hex");
 };
+var hashCacheKeyPartsIterable = (parts) => {
+	const hash = createHash("sha1");
+	for (const part of parts) {
+		hash.update(String(part.length));
+		hash.update(":");
+		hash.update(part);
+		hash.update(";");
+	}
+	return hash.digest("hex");
+};
 var getFileFingerprint = async (filePath) => {
 	const metadata = await stat(filePath);
 	return `${filePath}:${metadata.size}:${metadata.mtimeMs}`;
@@ -390,7 +404,8 @@ var getCachedJson = async (key) => {
 		return null;
 	}
 	if (parsed && typeof parsed === "object" && "version" in parsed && parsed.version === CACHE_ENVELOPE_VERSION && "value" in parsed) return parsed.value;
-	return parsed;
+	await rm(filePath, { force: true });
+	return null;
 };
 var setCachedJson = async (key, value) => {
 	await ensureCacheDir();
@@ -420,12 +435,24 @@ var invalidateCacheByPrefix = async (...prefixes) => {
 //#endregion
 //#region ../../src/lib/codex-thread-cache.ts
 var LARGE_THREAD_SIZE_BYTES = 100 * 1024 * 1024;
+var isMissingFileError$2 = (error) => {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+};
 var getCachedParsedCodexTranscript = async (sessionFile) => {
 	const fingerprint = await getFileFingerprint(sessionFile);
 	return withCachedJson(`thread-${hashCacheKeyParts(path.basename(sessionFile), fingerprint)}`, async () => parseCodexTranscriptFile(sessionFile));
 };
 var getThreadRolloutLoadState = async (sessionFile, largeTranscriptThresholdBytes = LARGE_THREAD_SIZE_BYTES) => {
-	const metadata = await stat(sessionFile);
+	let metadata;
+	try {
+		metadata = await stat(sessionFile);
+	} catch (error) {
+		if (isMissingFileError$2(error)) return {
+			fileSizeBytes: null,
+			shouldDeferTranscriptLoad: false
+		};
+		throw error;
+	}
 	return {
 		fileSizeBytes: metadata.size,
 		shouldDeferTranscriptLoad: metadata.size > largeTranscriptThresholdBytes
@@ -483,6 +510,13 @@ var runWithSqliteRetry = ({ action, delaysMs = DEFAULT_RETRY_DELAYS_MS, sleep =
 var SQLITE_DELETE_BATCH_SIZE = 400;
 var SESSION_FILE_DELETE_CONCURRENCY = 16;
 var THREAD_LIST_IO_CONCURRENCY = 8;
+var CODEX_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
+var JSONL_READ_CHUNK_BYTES = 64 * 1024;
+var SESSION_META_READ_LIMIT_BYTES = 4 * 1024 * 1024;
+var THREAD_ID_PATTERN = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/iu;
+var isSqliteCantOpenError = (error) => {
+	return error.code === "SQLITE_CANTOPEN";
+};
 var chunkValues = (values, chunkSize) => {
 	const chunks = [];
 	for (let index = 0; index < values.length; index += chunkSize) chunks.push(values.slice(index, index + chunkSize));
@@ -492,29 +526,16 @@ var isPromiseLike = (value) => {
 	if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
 	return "then" in value && typeof value.then === "function";
 };
-var mapWithConcurrency = async (values, limit, mapper) => {
-	const results = new Array(values.length);
-	let nextIndex = 0;
-	const worker = async () => {
-		while (true) {
-			const currentIndex = nextIndex;
-			nextIndex += 1;
-			if (currentIndex >= values.length) return;
-			results[currentIndex] = await mapper(values[currentIndex], currentIndex);
-		}
-	};
-	await Promise.all(Array.from({ length: Math.min(limit, values.length) }, () => worker()));
-	return results;
-};
-var openReadonlyDb = (dbPath, busyTimeoutMs) => {
+var openReadonlyDb = (dbPath) => {
 	const db = new Database(dbPath, { readonly: true });
 	try {
-		db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+		db.query("SELECT name FROM sqlite_master LIMIT 1").get();
 		return db;
 	} catch (error) {
 		db.close();
-		throw error;
+		if (!isSqliteCantOpenError(error)) throw error;
 	}
+	return new Database(`${pathToFileURL(dbPath).href}?immutable=1`, CODEX_READONLY_DB_OPEN_FLAGS);
 };
 var openWritableDb = (dbPath, busyTimeoutMs) => {
 	const db = new Database(dbPath);
@@ -550,7 +571,7 @@ var parseJsonSafely$1 = (value) => {
 };
 var withReadonlyDb = (dbPath, callback) => {
 	return runWithSqliteRetry({ action: () => {
-		const db = openReadonlyDb(dbPath, 5e3);
+		const db = openReadonlyDb(dbPath);
 		try {
 			const result = callback(db);
 			if (isPromiseLike(result)) throw new Error("Database callbacks must be synchronous");
@@ -581,9 +602,7 @@ var resolveCodexThreadDbPath = () => {
 		path.join(os.homedir(), ".codex", "state_5.sqlite")
 	];
 	for (const candidate of candidates) try {
-		runWithSqliteRetry({ action: () => {
-			return openReadonlyDb(candidate, 1500);
-		} }).close();
+		if (!statSync(candidate).isFile()) continue;
 		return candidate;
 	} catch {}
 	throw new Error(`Unable to open Codex thread database. Tried: ${candidates.join(", ")}`);
@@ -593,6 +612,256 @@ var readAllThreads = (dbPath) => {
 		return db.query("SELECT * FROM threads ORDER BY COALESCE(updated_at_ms, updated_at * 1000) DESC, id DESC").all();
 	});
 };
+var resolveCodexDirFromDbPath$1 = (dbPath) => {
+	const dbDir = path.dirname(dbPath);
+	return path.basename(dbDir) === "sqlite" ? path.dirname(dbDir) : dbDir;
+};
+var parseJsonlObject = (line) => {
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+};
+var emitJsonlLine = (line, onRecord) => {
+	const trimmed = line.trim();
+	const parsed = trimmed ? parseJsonlObject(trimmed) : null;
+	if (parsed) onRecord(parsed);
+};
+var emitCompleteJsonlLines = (text, onRecord) => {
+	const lines = text.split(/\r?\n/u);
+	const pending = lines.pop() ?? "";
+	for (const line of lines) emitJsonlLine(line, onRecord);
+	return pending;
+};
+var readJsonlObjects = (filePath, onRecord) => {
+	let descriptor = null;
+	try {
+		if (!statSync(filePath).isFile()) return;
+		descriptor = openSync(filePath, "r");
+		const buffer = Buffer.alloc(JSONL_READ_CHUNK_BYTES);
+		const decoder = new StringDecoder("utf8");
+		let position = 0;
+		let pending = "";
+		while (true) {
+			const bytesRead = readSync(descriptor, buffer, 0, buffer.length, position);
+			if (bytesRead === 0) break;
+			position += bytesRead;
+			pending += decoder.write(buffer.subarray(0, bytesRead));
+			pending = emitCompleteJsonlLines(pending, onRecord);
+		}
+		emitJsonlLine(pending + decoder.end(), onRecord);
+	} catch {
+		return;
+	} finally {
+		if (descriptor !== null) closeSync(descriptor);
+	}
+};
+var collectJsonlObjects = (filePath) => {
+	const records = [];
+	readJsonlObjects(filePath, (record) => {
+		records.push(record);
+	});
+	return records;
+};
+var readSessionIndexEntries = (codexDir) => {
+	return collectJsonlObjects(path.join(codexDir, "session_index.jsonl")).filter((entry) => typeof entry.id === "string" && entry.id.length > 0);
+};
+var collectSessionFilesByThreadId = (sessionsDir) => {
+	const sessionFiles = /* @__PURE__ */ new Map();
+	const visit = (directory) => {
+		const entries = (() => {
+			try {
+				return readdirSync(directory, { withFileTypes: true });
+			} catch {
+				return null;
+			}
+		})();
+		if (!entries) return;
+		for (const entry of entries) {
+			const entryPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				visit(entryPath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const threadId = THREAD_ID_PATTERN.exec(entry.name)?.[1];
+			if (threadId && !sessionFiles.has(threadId)) sessionFiles.set(threadId, entryPath);
+		}
+	};
+	visit(sessionsDir);
+	return sessionFiles;
+};
+var readSessionMetaLine = (sessionFile) => {
+	let descriptor = null;
+	try {
+		descriptor = openSync(sessionFile, "r");
+		const chunks = [];
+		let totalBytes = 0;
+		while (totalBytes < SESSION_META_READ_LIMIT_BYTES) {
+			const buffer = Buffer.alloc(Math.min(64 * 1024, SESSION_META_READ_LIMIT_BYTES - totalBytes));
+			const bytesRead = readSync(descriptor, buffer, 0, buffer.length, totalBytes);
+			if (bytesRead === 0) break;
+			chunks.push(buffer.subarray(0, bytesRead));
+			totalBytes += bytesRead;
+			if (buffer.subarray(0, bytesRead).includes(10)) break;
+		}
+		return Buffer.concat(chunks).toString("utf8").split(/\r?\n/u)[0]?.trim() || null;
+	} catch {
+		return null;
+	} finally {
+		if (descriptor !== null) closeSync(descriptor);
+	}
+};
+var readFallbackSessionMeta = (sessionFile) => {
+	const line = readSessionMetaLine(sessionFile);
+	if (!line) return null;
+	try {
+		const record = JSON.parse(line);
+		return record.type === "session_meta" && record.payload ? record.payload : null;
+	} catch {
+		return null;
+	}
+};
+var parseIsoMs = (value, fallback) => {
+	if (!value) return fallback;
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : fallback;
+};
+var stringOrNull = (value) => typeof value === "string" && value.length > 0 ? value : null;
+var numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var objectOrNull = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+};
+var isFallbackSubagent = (sessionMeta) => {
+	return Boolean(sessionMeta.thread_source === "subagent" || stringOrNull(sessionMeta.parent_thread_id) || stringOrNull(sessionMeta.forked_from_id));
+};
+var readFallbackRolloutStats = (sessionFile) => {
+	let model = null;
+	let tokensUsed = 0;
+	readJsonlObjects(sessionFile, (record) => {
+		const payload = objectOrNull(record.payload);
+		if (!payload) return;
+		if (record.type === "turn_context") {
+			model = stringOrNull(payload.model) ?? model;
+			return;
+		}
+		const payloadType = stringOrNull(payload.type);
+		if (payloadType === "message" || payloadType === "agent_message") {
+			model = stringOrNull(payload.model) ?? model;
+			return;
+		}
+		if (payloadType !== "token_count") return;
+		tokensUsed = numberOrNull(objectOrNull(objectOrNull(payload.info)?.total_token_usage)?.total_tokens) ?? tokensUsed;
+	});
+	return {
+		model,
+		tokensUsed
+	};
+};
+var buildFallbackThreadRow = (entry, sessionFile, sessionMeta, rolloutStats) => {
+	const cwd = stringOrNull(sessionMeta.cwd);
+	if (!cwd) return null;
+	let mtimeMs = Date.now();
+	try {
+		mtimeMs = statSync(sessionFile).mtimeMs;
+	} catch {}
+	const updatedAtMs = parseIsoMs(entry.updated_at, mtimeMs);
+	const createdAtMs = parseIsoMs(sessionMeta.timestamp, updatedAtMs);
+	const title = entry.thread_name?.trim() || path.basename(sessionFile, ".jsonl");
+	const source = stringOrNull(sessionMeta.source) ?? "session_file";
+	return {
+		agent_nickname: sessionMeta.agent_nickname ?? null,
+		agent_path: sessionMeta.agent_path ?? null,
+		agent_role: sessionMeta.agent_role ?? null,
+		approval_mode: "unknown",
+		archived: 0,
+		archived_at: null,
+		cli_version: sessionMeta.cli_version ?? "",
+		created_at: Math.floor(createdAtMs / 1e3),
+		created_at_ms: Math.floor(createdAtMs),
+		cwd,
+		first_user_message: title,
+		git_branch: null,
+		git_origin_url: null,
+		git_sha: null,
+		has_user_event: sessionMeta.thread_source === "user" ? 1 : 0,
+		id: entry.id,
+		memory_mode: "enabled",
+		model: rolloutStats.model,
+		model_provider: sessionMeta.model_provider ?? "unknown",
+		preview: title,
+		reasoning_effort: null,
+		rollout_path: sessionFile,
+		sandbox_policy: "{}",
+		source,
+		thread_source: sessionMeta.thread_source ?? null,
+		title,
+		tokens_used: rolloutStats.tokensUsed,
+		updated_at: Math.floor(updatedAtMs / 1e3),
+		updated_at_ms: Math.floor(updatedAtMs)
+	};
+};
+var readFallbackThreadRows = (dbPath, existingThreadIds, projectName = null, options = {}) => {
+	const codexDir = resolveCodexDirFromDbPath$1(dbPath);
+	const sessionFilesByThreadId = collectSessionFilesByThreadId(path.join(codexDir, "sessions"));
+	const fallbackThreads = [];
+	for (const entry of readSessionIndexEntries(codexDir)) {
+		if (existingThreadIds.has(entry.id)) continue;
+		const sessionFile = sessionFilesByThreadId.get(entry.id);
+		if (!sessionFile) continue;
+		const sessionMeta = readFallbackSessionMeta(sessionFile);
+		if (!sessionMeta) continue;
+		if (!options.includeSubagents && isFallbackSubagent(sessionMeta)) continue;
+		const fallbackThread = buildFallbackThreadRow(entry, sessionFile, sessionMeta, readFallbackRolloutStats(sessionFile));
+		if (!fallbackThread || projectName && getPortablePathBasename(fallbackThread.cwd) !== projectName) continue;
+		fallbackThreads.push(fallbackThread);
+	}
+	return fallbackThreads;
+};
+var mergeFallbackThreadRows = (dbPath, threads, projectName = null) => {
+	const threadIds = new Set(threads.map((thread) => thread.id));
+	return [...threads, ...readFallbackThreadRows(dbPath, threadIds, projectName)].sort((left, right) => {
+		const updatedDifference = toTimestampMs(right) - toTimestampMs(left);
+		if (updatedDifference !== 0) return updatedDifference;
+		return right.id.localeCompare(left.id);
+	});
+};
+var applyRolloutActivityTimestamps = (threads) => {
+	return threads.map((thread) => {
+		let rolloutUpdatedAtMs = toTimestampMs(thread);
+		try {
+			rolloutUpdatedAtMs = Math.max(rolloutUpdatedAtMs, statSync(thread.rollout_path).mtimeMs);
+		} catch {}
+		if (rolloutUpdatedAtMs <= toTimestampMs(thread)) return thread;
+		return {
+			...thread,
+			updated_at: Math.floor(rolloutUpdatedAtMs / 1e3),
+			updated_at_ms: Math.floor(rolloutUpdatedAtMs)
+		};
+	}).sort((left, right) => {
+		const updatedDifference = toTimestampMs(right) - toTimestampMs(left);
+		if (updatedDifference !== 0) return updatedDifference;
+		return right.id.localeCompare(left.id);
+	});
+};
+var buildDashboardRecentThreads = (threads) => {
+	const bestThreadByProject = /* @__PURE__ */ new Map();
+	for (const thread of threads) {
+		const project = getPortablePathBasename(thread.cwd);
+		if (!project) continue;
+		const current = bestThreadByProject.get(project);
+		if (!current || toTimestampMs(thread) > toTimestampMs(current)) bestThreadByProject.set(project, thread);
+	}
+	return [...bestThreadByProject.values()].sort((left, right) => {
+		const updatedDifference = toTimestampMs(right) - toTimestampMs(left);
+		if (updatedDifference !== 0) return updatedDifference;
+		return right.id.localeCompare(left.id);
+	}).slice(0, 5).map((thread) => ({
+		project: getPortablePathBasename(thread.cwd),
+		thread: compactThreadListRow(thread)
+	}));
+};
 var filterThreadsByProject = (threads, projectName) => {
 	if (!projectName) return threads;
 	return threads.filter((thread) => getPortablePathBasename(thread.cwd) === projectName);
@@ -697,7 +966,7 @@ var deleteThreadSessionFiles = async (sessionFiles) => {
 	return uniqueSessionFiles;
 };
 var listCodexProjects = (dbPath) => {
-	return mapProjectSummaries(buildProjectSummaryMap(readAllThreads(dbPath)));
+	return mapProjectSummaries(buildProjectSummaryMap(applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, readAllThreads(dbPath)))));
 };
 var compactThreadListRow = (thread) => {
 	return {
@@ -707,8 +976,19 @@ var compactThreadListRow = (thread) => {
 	};
 };
 var listProjectThreads = async (dbPath, projectName, options = {}) => {
-	return (await mapWithConcurrency(filterThreadsByProject(readAllThreads(dbPath), projectName), THREAD_LIST_IO_CONCURRENCY, async (thread) => {
+	return (await mapWithConcurrency(applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, filterThreadsByProject(readAllThreads(dbPath), projectName), projectName)), THREAD_LIST_IO_CONCURRENCY, async (thread) => {
 		const rollout = await getThreadRolloutLoadState(thread.rollout_path, options.largeTranscriptThresholdBytes);
+		if (rollout.fileSizeBytes === null) return {
+			project: projectName,
+			rolloutSizeBytes: null,
+			stats: {
+				deferred: false,
+				execCommandCount: 0,
+				toolCallCount: 0,
+				webSearchEventCount: 0
+			},
+			thread: compactThreadListRow(thread)
+		};
 		if (rollout.shouldDeferTranscriptLoad) return {
 			project: projectName,
 			rolloutSizeBytes: rollout.fileSizeBytes,
@@ -737,10 +1017,11 @@ var listProjectThreads = async (dbPath, projectName, options = {}) => {
 var getThreadBrowseData = (dbPath, threadId) => {
 	return withReadonlyDb(dbPath, (db) => {
 		const existingTableNames = getExistingTableNames(db);
-		const thread = db.query("SELECT * FROM threads WHERE id = ? LIMIT 1").get(threadId);
+		const dbThread = db.query("SELECT * FROM threads WHERE id = ? LIMIT 1").get(threadId);
+		const thread = dbThread ?? readFallbackThreadRows(dbPath, /* @__PURE__ */ new Set(), null, { includeSubagents: true }).find((fallbackThread) => fallbackThread.id === threadId) ?? null;
 		if (!thread) throw new Error(`Thread not found: ${threadId}`);
 		return {
-			dynamicTools: (existingTableNames.has("thread_dynamic_tools") ? db.query("SELECT thread_id, position, name, description, input_schema, defer_loading, namespace FROM thread_dynamic_tools WHERE thread_id = ? ORDER BY position ASC").all(threadId) : []).map((row) => parseDynamicToolRow(row)),
+			dynamicTools: (dbThread && existingTableNames.has("thread_dynamic_tools") ? db.query("SELECT thread_id, position, name, description, input_schema, defer_loading, namespace FROM thread_dynamic_tools WHERE thread_id = ? ORDER BY position ASC").all(threadId) : []).map((row) => parseDynamicToolRow(row)),
 			project: getPortablePathBasename(thread.cwd),
 			relations: getRelationsForThread(db, threadId, existingTableNames),
 			thread
@@ -748,7 +1029,7 @@ var getThreadBrowseData = (dbPath, threadId) => {
 	});
 };
 var getCodexDashboardSummary = (dbPath) => {
-	const threads = readAllThreads(dbPath);
+	const threads = applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, readAllThreads(dbPath)));
 	const projects = mapProjectSummaries(buildProjectSummaryMap(threads));
 	const threadsWithRelations = withReadonlyDb(dbPath, (db) => {
 		if (!getExistingTableNames(db).has("thread_spawn_edges")) return 0;
@@ -758,10 +1039,7 @@ var getCodexDashboardSummary = (dbPath) => {
 	return {
 		activeThreads: threads.filter((thread) => !thread.archived).length,
 		archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
-		recentThreads: threads.slice(0, 5).filter((thread) => Boolean(getPortablePathBasename(thread.cwd))).map((thread) => ({
-			project: getPortablePathBasename(thread.cwd),
-			thread: compactThreadListRow(thread)
-		})),
+		recentThreads: buildDashboardRecentThreads(threads),
 		threadsWithRelations,
 		topProjectsByThreadCount: [...projects].sort((left, right) => {
 			if (left.threadCount !== right.threadCount) return right.threadCount - left.threadCount;
@@ -828,13 +1106,16 @@ var deleteCodexProject = async (dbPath, projectName, options = {}) => {
 	}
 };
 var listScopedThreads = (dbPath, projectName) => {
-	return filterThreadsByProject(readAllThreads(dbPath), projectName);
+	return mergeFallbackThreadRows(dbPath, filterThreadsByProject(readAllThreads(dbPath), projectName), projectName);
 };
 var invalidateCodexUiCaches = async () => {
 	await invalidateCacheByPrefix("analytics-", "thread-");
 };
-//#endregion
-//#region ../../src/lib/codex-analytics.ts
+var resolveAnalyticsTranscriptConcurrency = (configuredValue = process.env.SPIRACHA_ANALYTICS_TRANSCRIPT_CONCURRENCY) => {
+	const parsed = Number(configuredValue);
+	if (!Number.isInteger(parsed) || parsed < 1) return 8;
+	return parsed;
+};
 var roundToTwoDecimals = (value) => {
 	return Number(value.toFixed(2));
 };
@@ -870,20 +1151,68 @@ var buildModelsByTokens = (threads) => {
 		return left.model.localeCompare(right.model);
 	});
 };
-var buildAnalyticsCacheKey = async (dbPath, threads, project) => {
-	const dbFingerprint = await getFileFingerprint(dbPath);
-	const rolloutFingerprints = await Promise.all(threads.map((thread) => getFileFingerprint(thread.rollout_path)));
-	return `analytics-${hashCacheKeyParts(dbFingerprint, project ?? "all", ...rolloutFingerprints)}`;
+var timestampSignature = (thread) => {
+	return String(thread.updated_at_ms ?? thread.updated_at * 1e3);
+};
+var threadMetadataCacheKeyParts = (thread) => [
+	thread.id,
+	thread.rollout_path,
+	timestampSignature(thread),
+	String(thread.created_at_ms ?? thread.created_at * 1e3),
+	String(thread.tokens_used),
+	String(thread.archived),
+	String(thread.archived_at ?? ""),
+	thread.cwd,
+	thread.model ?? "",
+	thread.model_provider,
+	thread.cli_version,
+	thread.title,
+	thread.preview
+];
+var buildCodexAnalyticsCacheKey = (dbPath, threads, project) => {
+	return `analytics-${hashCacheKeyPartsIterable((function* () {
+		yield "v2";
+		yield dbPath;
+		yield project ?? "all";
+		yield String(threads.length);
+		for (const thread of threads) yield* threadMetadataCacheKeyParts(thread);
+	})())}`;
+};
+var buildThreadAnalyticsCacheKey = (thread) => {
+	return `thread-analytics-${hashCacheKeyParts("v1", ...threadMetadataCacheKeyParts(thread))}`;
+};
+var parseThreadAnalyticsFile = async (sessionFile) => {
+	const toolNames = [];
+	let hasWebSearch = false;
+	for await (const parsed of readJsonlObjects$1(sessionFile)) {
+		if (parsed.type !== "response_item") continue;
+		const payload = asObject(parsed.payload);
+		if (!payload) continue;
+		const payloadType = asString(payload.type);
+		if (payloadType === "function_call") {
+			toolNames.push(asString(payload.name) ?? "unknown");
+			continue;
+		}
+		if (payloadType === "web_search_call" || payloadType === "web_search_end") hasWebSearch = true;
+	}
+	return {
+		hasWebSearch,
+		toolNames
+	};
+};
+var getCachedThreadAnalytics = async (thread) => {
+	return withCachedJson(buildThreadAnalyticsCacheKey(thread), () => parseThreadAnalyticsFile(thread.rollout_path));
 };
-var computeCodexAnalytics = async (threads) => {
+var computeCodexAnalyticsFromThreads = async (threads, options = {}) => {
 	const totalTokens = threads.reduce((sum, thread) => sum + thread.tokens_used, 0);
 	const projectNames = new Set(threads.map((thread) => getPortablePathBasename(thread.cwd)).filter(Boolean));
 	const toolUsage = /* @__PURE__ */ new Map();
-	const transcripts = await Promise.all(threads.map((thread) => getCachedParsedCodexTranscript(thread.rollout_path)));
 	let threadsWithWebSearch = 0;
-	for (const transcript of transcripts) {
-		if (transcript.stats.webSearchEventCount > 0) threadsWithWebSearch += 1;
-		for (const event of transcript.events) if (event.kind === "tool_call") incrementCount(toolUsage, event.name);
+	const loadThreadAnalytics = options.loadThreadAnalytics ?? getCachedThreadAnalytics;
+	const threadAnalytics = await mapWithConcurrency(threads, options.transcriptConcurrency ?? resolveAnalyticsTranscriptConcurrency(), (thread) => loadThreadAnalytics(thread));
+	for (const analytics of threadAnalytics) {
+		if (analytics.hasWebSearch) threadsWithWebSearch += 1;
+		for (const toolName of analytics.toolNames) incrementCount(toolUsage, toolName);
 	}
 	return {
 		modelsByTokens: buildModelsByTokens(threads),
@@ -904,7 +1233,7 @@ var computeCodexAnalytics = async (threads) => {
 };
 var getCodexAnalytics = async (input) => {
 	const threads = listScopedThreads(input.dbPath, input.project);
-	return withCachedJson(await buildAnalyticsCacheKey(input.dbPath, threads, input.project), async () => computeCodexAnalytics(threads));
+	return withCachedJson(buildCodexAnalyticsCacheKey(input.dbPath, threads, input.project), async () => computeCodexAnalyticsFromThreads(threads, { transcriptConcurrency: input.transcriptConcurrency }));
 };
 //#endregion
 //#region ../../src/lib/codex-exporter-db.ts
@@ -956,7 +1285,7 @@ var writeSessionFileExport = async (target, options, outputPath, transform = (te
 	let wroteSection = false;
 	try {
 		transcriptStream = await createExportWriteStream(transcriptOutputPath);
-		for await (const parsed of readJsonlObjects(target.sessionFile)) {
+		for await (const parsed of readJsonlObjects$1(target.sessionFile)) {
 			captureSessionMeta(parsed, state.sessionMeta);
 			const block = renderCodexTranscriptRecord(parsed, options, state);
 			if (!block) continue;
@@ -993,7 +1322,7 @@ var collectCodexTranscript = async (sessionFile, options, assistantModel = null)
 		sections: [],
 		sessionMeta: {}
 	};
-	for await (const parsed of readJsonlObjects(sessionFile)) processCodexTranscriptRecord(parsed, options, state);
+	for await (const parsed of readJsonlObjects$1(sessionFile)) processCodexTranscriptRecord(parsed, options, state);
 	return state;
 };
 var getSectionSeparator = () => "\n";
@@ -1388,47 +1717,20 @@ var extractContentPart = (value) => {
 	if (type === "input_image") return "[Image attached]";
 	return text ?? "";
 };
-var UI_EXPORT_URL_PREFIX = "/__exports/";
-var DEFAULT_UI_EXPORT_DIR = path.join(os.tmpdir(), "spiracha-ui-exports");
-var DEFAULT_EXPORT_MAX_AGE_MS = 1440 * 60 * 1e3;
-var getUiExportDir = () => {
-	return process.env["SPIRACHA_UI_EXPORT_DIR"]?.trim() || DEFAULT_UI_EXPORT_DIR;
-};
-var ensureUiExportDir = async () => {
-	const exportDir = getUiExportDir();
-	await mkdir(exportDir, { recursive: true });
-	await purgeStaleUiExports(exportDir);
-	return exportDir;
-};
-var buildUiExportDownloadUrl = (filePath) => {
-	return `${UI_EXPORT_URL_PREFIX}${encodeURIComponent(path.basename(filePath))}`;
-};
-var purgeStaleUiExports = async (exportDir = getUiExportDir(), maxAgeMs = DEFAULT_EXPORT_MAX_AGE_MS) => {
-	const entries = await readdir(exportDir, { withFileTypes: true });
-	const cutoff = Date.now() - maxAgeMs;
-	await Promise.all(entries.filter((entry) => entry.isFile()).map(async (entry) => {
-		const filePath = path.join(exportDir, entry.name);
-		if ((await stat(filePath)).mtimeMs >= cutoff) return;
-		await rm(filePath, { force: true });
-	}));
-};
 //#endregion
 //#region ../../src/lib/codex-browser-export.ts
 var LARGE_BROWSER_EXPORT_THRESHOLD_BYTES = 128 * 1024 * 1024;
-var toSanitizedFileName = (value) => {
-	return value.replace(/[<>:"/\\|?*\u0000-\u001f]/gu, " ").replace(/\.\.+/gu, " ").replace(/\s+/gu, " ").trim();
-};
 var formatReadableExportDate = (value) => {
 	const date = new Date(value);
 	return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}-${String(date.getUTCHours()).padStart(2, "0")}${String(date.getUTCMinutes()).padStart(2, "0")}`;
 };
 var buildExportBaseName = (thread) => {
-	return `${toSanitizedFileName(getPortablePathBasename(thread.cwd) || "thread") || "thread"}-${formatReadableExportDate(thread.updated_at_ms ?? thread.updated_at * 1e3)}-${thread.id.slice(0, 8)}`;
+	return `${sanitizeExportFileName(getPortablePathBasename(thread.cwd) || "thread") || "thread"}-${formatReadableExportDate(thread.updated_at_ms ?? thread.updated_at * 1e3)}-${thread.id.slice(0, 8)}`;
 };
 var buildBatchExportBaseName = (threads) => {
 	const firstThread = threads[0];
 	if (!firstThread) throw new Error("No threads selected for export");
-	return `${toSanitizedFileName(getPortablePathBasename(firstThread.cwd) || "threads") || "threads"}-${formatReadableExportDate(Math.max(...threads.map((thread) => thread.updated_at_ms ?? thread.updated_at * 1e3)))}-threads-${threads.length}`;
+	return `${sanitizeExportFileName(getPortablePathBasename(firstThread.cwd) || "threads") || "threads"}-${formatReadableExportDate(Math.max(...threads.map((thread) => thread.updated_at_ms ?? thread.updated_at * 1e3)))}-threads-${threads.length}`;
 };
 var buildUniqueArchivePath = (exportDir, exportBaseName) => {
 	return path.join(exportDir, `${exportBaseName}-${randomUUID()}.zip`);
@@ -1457,9 +1759,6 @@ var toDownloadOptions = (input) => {
 		threadIds: [input.threadId]
 	};
 };
-var getMimeType = (outputFormat) => {
-	return outputFormat === "md" ? "text/markdown; charset=utf-8" : "text/plain; charset=utf-8";
-};
 var resolvePublicExportDir = async (publicExportDir) => {
 	if (publicExportDir) {
 		await ensureDirectory(publicExportDir);
@@ -1480,17 +1779,27 @@ var getRolloutSnapshot = async (rolloutPath) => {
 		sizeBytes: metadata.size
 	};
 };
+var isMissingFileError$1 = (error) => {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+};
+var getExistingRolloutSnapshot = async (threadId, rolloutPath) => {
+	try {
+		return await getRolloutSnapshot(rolloutPath);
+	} catch (error) {
+		if (isMissingFileError$1(error)) throw new Error(`Thread ${threadId} rollout file is missing: ${rolloutPath}`, { cause: error });
+		throw error;
+	}
+};
 var logExportEvent = (level, event, details) => {
 	console[level](`[spiracha:export] ${event}`, details);
 };
-var logRolloutChangeIfDetected = (threadId, rolloutPath, beforeSnapshot, afterSnapshot) => {
+var logRolloutChangeIfDetected = (threadId, beforeSnapshot, afterSnapshot) => {
 	if (beforeSnapshot.mtimeMs === afterSnapshot.mtimeMs && beforeSnapshot.sizeBytes === afterSnapshot.sizeBytes) return;
 	logExportEvent("warn", "rollout_changed_during_export", {
 		afterMtimeMs: afterSnapshot.mtimeMs,
 		afterSizeBytes: afterSnapshot.sizeBytes,
 		beforeMtimeMs: beforeSnapshot.mtimeMs,
 		beforeSizeBytes: beforeSnapshot.sizeBytes,
-		rolloutPath,
 		threadId
 	});
 };
@@ -1507,63 +1816,25 @@ var cleanupExportWorkspace = async (workspacePath) => {
 		});
 	}
 };
-var zipExportFile = async (sourcePath, zipPath) => {
-	const proc = Bun.spawn([
-		"zip",
-		"-9",
-		"-j",
-		zipPath,
-		sourcePath
-	], {
-		stderr: "pipe",
-		stdout: "pipe"
-	});
-	const [stdoutText, stderrText, exitCode] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		proc.exited
-	]);
-	if (exitCode !== 0) throw new Error(`zip failed (${exitCode}): ${(stderrText || stdoutText).trim()}`);
-};
-var zipExportDirectory = async (sourceDirectory, zipPath) => {
-	const proc = Bun.spawn([
-		"zip",
-		"-9",
-		"-r",
-		zipPath,
-		"."
-	], {
-		cwd: sourceDirectory,
-		stderr: "pipe",
-		stdout: "pipe"
-	});
-	const [stdoutText, stderrText, exitCode] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		proc.exited
-	]);
-	if (exitCode !== 0) throw new Error(`zip failed (${exitCode}): ${(stderrText || stdoutText).trim()}`);
-};
 var renderCodexThreadDownload = async (input) => {
 	const startedAt = Date.now();
 	const browseData = getThreadBrowseData(input.dbPath, input.threadId);
 	const extension = input.outputFormat === "md" ? "md" : "txt";
 	const fileBaseName = buildExportBaseName(browseData.thread);
 	const fileName = `${fileBaseName}.${extension}`;
-	const mimeType = getMimeType(input.outputFormat);
+	const mimeType = getExportMimeType(input.outputFormat);
 	const transform = (text) => input.pathDisplaySettings ? applyPathTransforms(text, {
 		...input.pathDisplaySettings,
 		projectPath: browseData.thread.cwd
 	}) : text;
-	const rolloutSnapshotBefore = await getRolloutSnapshot(browseData.thread.rollout_path);
+	const rolloutSnapshotBefore = await getExistingRolloutSnapshot(input.threadId, browseData.thread.rollout_path);
 	logExportEvent("info", "single_start", {
 		fileName,
-		rolloutPath: browseData.thread.rollout_path,
 		sizeBytes: rolloutSnapshotBefore.sizeBytes,
 		threadId: input.threadId
 	});
 	try {
-		if (rolloutSnapshotBefore.sizeBytes > (input.largeExportThresholdBytes ?? LARGE_BROWSER_EXPORT_THRESHOLD_BYTES)) {
+		if (input.zipArchive || rolloutSnapshotBefore.sizeBytes > (input.largeExportThresholdBytes ?? LARGE_BROWSER_EXPORT_THRESHOLD_BYTES)) {
 			const exportBaseName = fileBaseName;
 			const exportDir = await resolvePublicExportDir(input.publicExportDir);
 			const workspaceDir = await createExportWorkspace(exportDir, exportBaseName);
@@ -1582,7 +1853,7 @@ var renderCodexThreadDownload = async (input) => {
 				await cleanupExportWorkspace(workspaceDir);
 			}
 			const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-			logRolloutChangeIfDetected(input.threadId, browseData.thread.rollout_path, rolloutSnapshotBefore, rolloutSnapshotAfter);
+			logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
 			const zipStat = await Bun.file(zipPath).stat();
 			logExportEvent("info", "single_zip_ready", {
 				downloadUrl: buildUiExportDownloadUrl(zipPath),
@@ -1608,7 +1879,7 @@ var renderCodexThreadDownload = async (input) => {
 		}, toDownloadOptions(input));
 		if (!content) throw new Error(`Thread ${input.threadId} produced no exportable content`);
 		const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-		logRolloutChangeIfDetected(input.threadId, browseData.thread.rollout_path, rolloutSnapshotBefore, rolloutSnapshotAfter);
+		logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
 		logExportEvent("info", "single_inline_ready", {
 			durationMs: Date.now() - startedAt,
 			fileName,
@@ -1649,7 +1920,7 @@ var renderCodexThreadsDownload = async (input) => {
 	});
 	try {
 		for (const entry of browseEntries) {
-			const rolloutSnapshotBefore = await getRolloutSnapshot(entry.thread.rollout_path);
+			const rolloutSnapshotBefore = await getExistingRolloutSnapshot(entry.thread.id, entry.thread.rollout_path);
 			const singleBaseName = buildExportBaseName(entry.thread);
 			const uniqueBaseName = buildUniqueBatchEntryBaseName(singleBaseName, entry.thread.id, usedBatchEntryBaseNames);
 			const relativeFileName = `${uniqueBaseName}.${input.outputFormat === "md" ? "md" : "txt"}`;
@@ -1677,7 +1948,7 @@ var renderCodexThreadsDownload = async (input) => {
 				threadIds: [entry.thread.id]
 			}, savedPath, transform)) throw new Error(`Thread ${entry.thread.id} produced no exportable content`);
 			const rolloutSnapshotAfter = await getRolloutSnapshot(entry.thread.rollout_path);
-			logRolloutChangeIfDetected(entry.thread.id, entry.thread.rollout_path, rolloutSnapshotBefore, rolloutSnapshotAfter);
+			logRolloutChangeIfDetected(entry.thread.id, rolloutSnapshotBefore, rolloutSnapshotAfter);
 		}
 		await zipExportDirectory(bundleDirectory, zipPath);
 	} catch (error) {
@@ -1863,7 +2134,8 @@ var exportSchema = z.object({
 	includeTools: z.boolean(),
 	outputFormat: z.enum(["md", "txt"]),
 	redactUsername: z.boolean(),
-	threadId: z.string().min(1)
+	threadId: z.string().min(1),
+	zipArchive: z.boolean().default(false)
 });
 var exportThreadsSchema = z.object({
 	convertToProjectRoot: z.boolean(),
@@ -1872,7 +2144,8 @@ var exportThreadsSchema = z.object({
 	includeTools: z.boolean(),
 	outputFormat: z.enum(["md", "txt"]),
 	redactUsername: z.boolean(),
-	threadIds: z.array(z.string().min(1)).min(1)
+	threadIds: z.array(z.string().min(1)).min(1),
+	zipArchive: z.boolean().default(true)
 });
 var getDbPath = () => process.env.SPIRACHA_CODEX_DB?.trim() || resolveCodexThreadDbPath();
 var isMissingFileError = (error) => {
@@ -1899,7 +2172,7 @@ var listProjectThreadsFn_createServerFn_handler = createServerRpc({
 	name: "listProjectThreadsFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => listProjectThreadsFn.__executeServer(opts));
-var listProjectThreadsFn = createServerFn({ method: "GET" }).inputValidator(projectSchema).handler(listProjectThreadsFn_createServerFn_handler, async ({ data }) => {
+var listProjectThreadsFn = createServerFn({ method: "GET" }).validator(projectSchema).handler(listProjectThreadsFn_createServerFn_handler, async ({ data }) => {
 	return listProjectThreads(getDbPath(), data.project);
 });
 var getThreadSnapshotFn_createServerFn_handler = createServerRpc({
@@ -1907,7 +2180,7 @@ var getThreadSnapshotFn_createServerFn_handler = createServerRpc({
 	name: "getThreadSnapshotFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => getThreadSnapshotFn.__executeServer(opts));
-var getThreadSnapshotFn = createServerFn({ method: "GET" }).inputValidator(threadSchema).handler(getThreadSnapshotFn_createServerFn_handler, async ({ data }) => {
+var getThreadSnapshotFn = createServerFn({ method: "GET" }).validator(threadSchema).handler(getThreadSnapshotFn_createServerFn_handler, async ({ data }) => {
 	const browseData = getThreadBrowseData(getDbPath(), data.threadId);
 	const rollout = await getThreadRolloutLoadState(browseData.thread.rollout_path);
 	let transcript = null;
@@ -1931,7 +2204,7 @@ var getThreadTranscriptFn_createServerFn_handler = createServerRpc({
 	name: "getThreadTranscriptFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => getThreadTranscriptFn.__executeServer(opts));
-var getThreadTranscriptFn = createServerFn({ method: "GET" }).inputValidator(threadSchema).handler(getThreadTranscriptFn_createServerFn_handler, async ({ data }) => {
+var getThreadTranscriptFn = createServerFn({ method: "GET" }).validator(threadSchema).handler(getThreadTranscriptFn_createServerFn_handler, async ({ data }) => {
 	return getCachedThreadTranscriptPreview(getThreadBrowseData(getDbPath(), data.threadId).thread.rollout_path);
 });
 var getAnalyticsFn_createServerFn_handler = createServerRpc({
@@ -1939,7 +2212,7 @@ var getAnalyticsFn_createServerFn_handler = createServerRpc({
 	name: "getAnalyticsFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => getAnalyticsFn.__executeServer(opts));
-var getAnalyticsFn = createServerFn({ method: "GET" }).inputValidator(analyticsSchema).handler(getAnalyticsFn_createServerFn_handler, async ({ data }) => {
+var getAnalyticsFn = createServerFn({ method: "GET" }).validator(analyticsSchema).handler(getAnalyticsFn_createServerFn_handler, async ({ data }) => {
 	return getCodexAnalytics({
 		dbPath: getDbPath(),
 		project: data.project
@@ -1950,7 +2223,7 @@ var exportThreadFn_createServerFn_handler = createServerRpc({
 	name: "exportThreadFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => exportThreadFn.__executeServer(opts));
-var exportThreadFn = createServerFn({ method: "POST" }).inputValidator(exportSchema).handler(exportThreadFn_createServerFn_handler, async ({ data }) => {
+var exportThreadFn = createServerFn({ method: "POST" }).validator(exportSchema).handler(exportThreadFn_createServerFn_handler, async ({ data }) => {
 	return renderCodexThreadDownload({
 		dbPath: getDbPath(),
 		includeCommentary: data.includeCommentary,
@@ -1961,7 +2234,8 @@ var exportThreadFn = createServerFn({ method: "POST" }).inputValidator(exportSch
 			convertToProjectRoot: data.convertToProjectRoot,
 			redactUsername: data.redactUsername
 		},
-		threadId: data.threadId
+		threadId: data.threadId,
+		zipArchive: data.zipArchive
 	});
 });
 var exportThreadsFn_createServerFn_handler = createServerRpc({
@@ -1969,7 +2243,7 @@ var exportThreadsFn_createServerFn_handler = createServerRpc({
 	name: "exportThreadsFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => exportThreadsFn.__executeServer(opts));
-var exportThreadsFn = createServerFn({ method: "POST" }).inputValidator(exportThreadsSchema).handler(exportThreadsFn_createServerFn_handler, async ({ data }) => {
+var exportThreadsFn = createServerFn({ method: "POST" }).validator(exportThreadsSchema).handler(exportThreadsFn_createServerFn_handler, async ({ data }) => {
 	return renderCodexThreadsDownload({
 		dbPath: getDbPath(),
 		includeCommentary: data.includeCommentary,
@@ -1980,7 +2254,8 @@ var exportThreadsFn = createServerFn({ method: "POST" }).inputValidator(exportTh
 			convertToProjectRoot: data.convertToProjectRoot,
 			redactUsername: data.redactUsername
 		},
-		threadIds: data.threadIds
+		threadIds: data.threadIds,
+		zipArchive: data.zipArchive
 	});
 });
 var deleteThreadFn_createServerFn_handler = createServerRpc({
@@ -1988,7 +2263,7 @@ var deleteThreadFn_createServerFn_handler = createServerRpc({
 	name: "deleteThreadFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => deleteThreadFn.__executeServer(opts));
-var deleteThreadFn = createServerFn({ method: "POST" }).inputValidator(deleteThreadSchema).handler(deleteThreadFn_createServerFn_handler, async ({ data }) => {
+var deleteThreadFn = createServerFn({ method: "POST" }).validator(deleteThreadSchema).handler(deleteThreadFn_createServerFn_handler, async ({ data }) => {
 	return deleteCodexThread(getDbPath(), data.threadId, { deleteSessionFiles: data.deleteSessionFiles });
 });
 var deleteThreadsFn_createServerFn_handler = createServerRpc({
@@ -1996,7 +2271,7 @@ var deleteThreadsFn_createServerFn_handler = createServerRpc({
 	name: "deleteThreadsFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => deleteThreadsFn.__executeServer(opts));
-var deleteThreadsFn = createServerFn({ method: "POST" }).inputValidator(deleteThreadsSchema).handler(deleteThreadsFn_createServerFn_handler, async ({ data }) => {
+var deleteThreadsFn = createServerFn({ method: "POST" }).validator(deleteThreadsSchema).handler(deleteThreadsFn_createServerFn_handler, async ({ data }) => {
 	return deleteCodexThreads(getDbPath(), data.threadIds, { deleteSessionFiles: data.deleteSessionFiles });
 });
 var deleteProjectFn_createServerFn_handler = createServerRpc({
@@ -2004,7 +2279,7 @@ var deleteProjectFn_createServerFn_handler = createServerRpc({
 	name: "deleteProjectFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => deleteProjectFn.__executeServer(opts));
-var deleteProjectFn = createServerFn({ method: "POST" }).inputValidator(deleteProjectSchema).handler(deleteProjectFn_createServerFn_handler, async ({ data }) => {
+var deleteProjectFn = createServerFn({ method: "POST" }).validator(deleteProjectSchema).handler(deleteProjectFn_createServerFn_handler, async ({ data }) => {
 	return deleteCodexProject(getDbPath(), data.project, { deleteSessionFiles: data.deleteSessionFiles });
 });
 var recoverProjectThreadsFn_createServerFn_handler = createServerRpc({
@@ -2012,7 +2287,7 @@ var recoverProjectThreadsFn_createServerFn_handler = createServerRpc({
 	name: "recoverProjectThreadsFn",
 	filename: "src/lib/codex-server.ts"
 }, (opts) => recoverProjectThreadsFn.__executeServer(opts));
-var recoverProjectThreadsFn = createServerFn({ method: "POST" }).inputValidator(projectSchema).handler(recoverProjectThreadsFn_createServerFn_handler, async ({ data }) => {
+var recoverProjectThreadsFn = createServerFn({ method: "POST" }).validator(projectSchema).handler(recoverProjectThreadsFn_createServerFn_handler, async ({ data }) => {
 	return recoverCodexProjectThreads(getDbPath(), data.project);
 });
 //#endregion