spiracha 1.5.0 → 2.0.0

package/apps/ui/dist/server/assets/codex-server-CGXU4H8-.js

@@ -1,2294 +0,0 @@
-import { t as createServerFn } from "../server.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 { 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 { 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");
-path.join(DEFAULT_CODEX_DIR, "sessions");
-path.join(process.cwd(), "exports");
-//#endregion
-//#region ../../src/lib/codex-thread-parser.ts
-var createEmptyStats = () => {
-	return {
-		assistantMessageCount: 0,
-		commentaryCount: 0,
-		execCommandCount: 0,
-		finalAnswerCount: 0,
-		messageCount: 0,
-		toolCallCount: 0,
-		toolOutputCount: 0,
-		userMessageCount: 0,
-		webSearchEventCount: 0
-	};
-};
-var createEmptySessionMeta = () => {
-	return {
-		baseInstructions: null,
-		cli_version: void 0,
-		cwd: void 0,
-		dynamicTools: [],
-		git: null,
-		id: void 0,
-		modelProvider: null,
-		originator: void 0,
-		source: void 0,
-		threadSource: null,
-		timestamp: void 0
-	};
-};
-var parseCodexTranscriptFile = async (sessionFile, options = {}) => {
-	const sessionMeta = createEmptySessionMeta();
-	const turnContexts = [];
-	const events = [];
-	const stats = createEmptyStats();
-	const includeRaw = options.includeRaw ?? true;
-	const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
-	const maxTurnContexts = options.maxTurnContexts ?? Number.POSITIVE_INFINITY;
-	let sequence = 0;
-	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);
-			continue;
-		}
-		const event = toThreadEvent(parsed, sequence, includeRaw);
-		if (!event) continue;
-		events.push(event);
-		updateTranscriptStats(stats, event);
-		sequence += 1;
-		if (events.length >= maxEvents) break;
-	}
-	return {
-		events,
-		isPartial: Number.isFinite(maxEvents) || Number.isFinite(maxTurnContexts),
-		rawIncluded: includeRaw,
-		sessionMeta,
-		sourceFileSizeBytes: options.sourceFileSizeBytes ?? null,
-		stats,
-		statsArePartial: Number.isFinite(maxEvents),
-		turnContexts
-	};
-};
-var captureSessionMeta$1 = (parsed, sessionMeta) => {
-	if (parsed.type !== "session_meta") return;
-	const payload = asObject(parsed.payload);
-	if (!payload) return;
-	sessionMeta.baseInstructions = payload.base_instructions ?? sessionMeta.baseInstructions;
-	sessionMeta.cli_version = asString(payload.cli_version) ?? sessionMeta.cli_version;
-	sessionMeta.cwd = asString(payload.cwd) ?? sessionMeta.cwd;
-	sessionMeta.dynamicTools = parseDynamicTools(payload.dynamic_tools) ?? sessionMeta.dynamicTools;
-	sessionMeta.git = asObject(payload.git) ?? sessionMeta.git;
-	sessionMeta.id = asString(payload.id) ?? sessionMeta.id;
-	sessionMeta.modelProvider = asString(payload.model_provider) ?? sessionMeta.modelProvider;
-	sessionMeta.originator = asString(payload.originator) ?? sessionMeta.originator;
-	sessionMeta.source = asString(payload.source) ?? sessionMeta.source;
-	sessionMeta.threadSource = asString(payload.thread_source) ?? sessionMeta.threadSource;
-	sessionMeta.timestamp = asString(payload.timestamp) ?? sessionMeta.timestamp;
-};
-var parseDynamicTools = (value) => {
-	if (!Array.isArray(value)) return null;
-	return value.flatMap((entry) => {
-		const tool = asObject(entry);
-		if (!tool) return [];
-		return [{
-			deferLoading: tool.deferLoading === true || tool.defer_loading === true,
-			description: asString(tool.description) ?? "",
-			inputSchema: asObject(tool.inputSchema) ?? asObject(tool.input_schema) ?? null,
-			name: asString(tool.name) ?? "unknown",
-			namespace: asString(tool.namespace)
-		}];
-	});
-};
-var captureTurnContext = (parsed, turnContexts) => {
-	const payload = asObject(parsed.payload);
-	if (!payload) return;
-	turnContexts.push({
-		payload,
-		timestamp: asString(parsed.timestamp)
-	});
-};
-var toThreadEvent = (parsed, sequence, includeRaw) => {
-	const payload = asObject(parsed.payload);
-	if (!payload) return null;
-	const payloadType = asString(payload.type);
-	const timestamp = asString(parsed.timestamp);
-	if (parsed.type === "event_msg") return buildEventMessage(payload, payloadType, includeRaw ? parsed : {}, sequence, timestamp);
-	if (parsed.type !== "response_item") return null;
-	return buildResponseItemEvent(payload, payloadType, includeRaw ? parsed : {}, sequence, timestamp);
-};
-var buildEventMessage = (payload, payloadType, raw, sequence, timestamp) => {
-	if (payloadType === "task_started") return createTaskStartedEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "task_complete") return createTaskCompleteEvent(payload, raw, sequence, timestamp);
-	return null;
-};
-var buildResponseItemEvent = (payload, payloadType, raw, sequence, timestamp) => {
-	if (payloadType === "message") return createMessageEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "user_message") return createUserMessageEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "agent_message") return createAgentMessageEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "function_call") return createToolCallEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "function_call_output") return createToolOutputEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "reasoning") return createReasoningEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "token_count") return createTokenCountEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "web_search_call" || payloadType === "web_search_end") return createWebSearchEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "task_started") return createTaskStartedEvent(payload, raw, sequence, timestamp);
-	if (payloadType === "task_complete") return createTaskCompleteEvent(payload, raw, sequence, timestamp);
-	return null;
-};
-var createMessageEvent = (payload, raw, sequence, timestamp) => {
-	const role = asString(payload.role);
-	const content = payload.content;
-	if (!role || content === void 0) return null;
-	return {
-		isHiddenByDefault: shouldHideTranscriptText(role, extractText$1(content)),
-		kind: "message",
-		memoryCitation: null,
-		model: asString(payload.model),
-		phase: asString(payload.phase),
-		raw,
-		role,
-		sequence,
-		text: extractText$1(content),
-		timestamp,
-		variant: "message"
-	};
-};
-var createUserMessageEvent = (payload, raw, sequence, timestamp) => {
-	return {
-		isHiddenByDefault: shouldHideTranscriptText("user", asString(payload.message)?.trim() ?? ""),
-		kind: "message",
-		memoryCitation: null,
-		model: null,
-		phase: null,
-		raw,
-		role: "user",
-		sequence,
-		text: asString(payload.message)?.trim() ?? "",
-		timestamp,
-		variant: "user_message"
-	};
-};
-var createAgentMessageEvent = (payload, raw, sequence, timestamp) => {
-	return {
-		isHiddenByDefault: false,
-		kind: "message",
-		memoryCitation: payload.memory_citation ?? null,
-		model: asString(payload.model),
-		phase: asString(payload.phase),
-		raw,
-		role: "assistant",
-		sequence,
-		text: asString(payload.message)?.trim() ?? "",
-		timestamp,
-		variant: "agent_message"
-	};
-};
-var createToolCallEvent = (payload, raw, sequence, timestamp) => {
-	const name = asString(payload.name) ?? "unknown";
-	const argumentsText = asString(payload.arguments);
-	const parsedArguments = parseExecCommandArguments$1(argumentsText);
-	return {
-		argumentsParseFailed: parsedArguments.argumentsParseFailed,
-		argumentsText,
-		callId: asString(payload.call_id),
-		command: parsedArguments.cmd,
-		kind: "tool_call",
-		name,
-		raw,
-		sequence,
-		timestamp,
-		workdir: parsedArguments.workdir
-	};
-};
-var createToolOutputEvent = (payload, raw, sequence, timestamp) => {
-	const outputText = asString(payload.output) ?? "";
-	return {
-		callId: asString(payload.call_id),
-		exitCode: parseExitCode(outputText),
-		kind: "tool_output",
-		outputText,
-		raw,
-		sequence,
-		summary: formatToolOutputSummary$1(outputText),
-		timestamp,
-		wallTime: parseWallTime(outputText)
-	};
-};
-var createReasoningEvent = (payload, raw, sequence, timestamp) => {
-	return {
-		content: payload.content ?? null,
-		hasEncryptedContent: Boolean(asString(payload.encrypted_content)),
-		kind: "reasoning",
-		raw,
-		sequence,
-		summary: toStringArray(payload.summary),
-		timestamp
-	};
-};
-var createTokenCountEvent = (payload, raw, sequence, timestamp) => {
-	return {
-		info: payload.info ?? null,
-		kind: "token_count",
-		rateLimits: payload.rate_limits ?? null,
-		raw,
-		sequence,
-		timestamp
-	};
-};
-var createTaskStartedEvent = (payload, raw, sequence, timestamp) => {
-	return {
-		collaborationModeKind: asString(payload.collaboration_mode_kind),
-		kind: "task_started",
-		modelContextWindow: asNumber(payload.model_context_window),
-		raw,
-		sequence,
-		startedAt: asNumber(payload.started_at),
-		timestamp,
-		turnId: asString(payload.turn_id)
-	};
-};
-var createTaskCompleteEvent = (payload, raw, sequence, timestamp) => {
-	return {
-		completedAt: asNumber(payload.completed_at),
-		durationMs: asNumber(payload.duration_ms),
-		kind: "task_complete",
-		lastAgentMessage: asString(payload.last_agent_message),
-		raw,
-		sequence,
-		timestamp,
-		timeToFirstTokenMs: asNumber(payload.time_to_first_token_ms),
-		turnId: asString(payload.turn_id)
-	};
-};
-var createWebSearchEvent = (payload, raw, sequence, timestamp) => {
-	const payloadType = asString(payload.type);
-	return {
-		action: payload.action ?? null,
-		callId: asString(payload.call_id),
-		kind: "web_search",
-		phase: payloadType === "web_search_end" ? "end" : "call",
-		query: asString(payload.query),
-		raw,
-		sequence,
-		status: asString(payload.status),
-		timestamp
-	};
-};
-var updateTranscriptStats = (stats, event) => {
-	if (event.kind === "message") {
-		stats.messageCount += 1;
-		if (event.role === "assistant") stats.assistantMessageCount += 1;
-		if (event.role === "user") stats.userMessageCount += 1;
-		if (event.phase === "commentary") stats.commentaryCount += 1;
-		if (event.phase === "final_answer") stats.finalAnswerCount += 1;
-		return;
-	}
-	if (event.kind === "tool_call") {
-		stats.toolCallCount += 1;
-		if (event.name === "exec_command") stats.execCommandCount += 1;
-		return;
-	}
-	if (event.kind === "tool_output") {
-		stats.toolOutputCount += 1;
-		return;
-	}
-	if (event.kind === "web_search") stats.webSearchEventCount += 1;
-};
-var toStringArray = (value) => {
-	if (!Array.isArray(value)) return [];
-	return value.map((entry) => asString(entry)).filter((entry) => Boolean(entry));
-};
-var parseExitCode = (outputText) => {
-	const match = /Process exited with code (\d+)/u.exec(outputText);
-	return match ? Number(match[1]) : null;
-};
-var parseWallTime = (outputText) => {
-	return /Wall time: ([^\n]+)/u.exec(outputText)?.[1] ?? null;
-};
-var formatToolOutputSummary$1 = (outputText) => {
-	return outputText.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => {
-		return line.startsWith("Command: ") || line.startsWith("Process exited with code ") || line.startsWith("Wall time: ");
-	}).join("\n");
-};
-var parseExecCommandArguments$1 = (argumentsText) => {
-	if (!argumentsText) return {
-		argumentsParseFailed: false,
-		cmd: null,
-		workdir: null
-	};
-	try {
-		const parsed = JSON.parse(argumentsText);
-		return {
-			argumentsParseFailed: false,
-			cmd: typeof parsed.cmd === "string" ? parsed.cmd : null,
-			workdir: typeof parsed.workdir === "string" ? parsed.workdir : null
-		};
-	} catch {
-		return {
-			argumentsParseFailed: true,
-			cmd: null,
-			workdir: null
-		};
-	}
-};
-var extractText$1 = (content) => {
-	if (typeof content === "string") return content.trim();
-	if (Array.isArray(content)) return content.map((entry) => extractTextPart(entry)).filter(Boolean).join("\n\n").trim();
-	if (content && typeof content === "object") return asString(content.text)?.trim() ?? "";
-	return "";
-};
-var extractTextPart = (entry) => {
-	const objectValue = asObject(entry);
-	if (!objectValue) return "";
-	const type = asString(objectValue.type);
-	const text = asString(objectValue.text);
-	if (type === "input_image") return "[Image attached]";
-	return text ?? "";
-};
-var shouldHideTranscriptText = (role, text) => {
-	if (!text) return true;
-	if (role === "developer") return true;
-	return text.startsWith("# AGENTS.md instructions for ") || text.startsWith("<permissions instructions>") || text.startsWith("<app-context>") || text.startsWith("<environment_context>") || text.startsWith("<collaboration_mode>") || text.startsWith("<skills_instructions>") || text.startsWith("<plugins_instructions>") || text.includes("Filesystem sandboxing defines which files can be read or written.");
-};
-//#endregion
-//#region ../../src/lib/ui-cache.ts
-var CACHE_DIR = path.join(os.tmpdir(), "spiracha-ui-cache");
-var CACHE_ENVELOPE_VERSION = 1;
-var ensureCacheDir = async () => {
-	await mkdir(CACHE_DIR, { recursive: true });
-};
-var toCachePath = (key) => {
-	const safeKey = key.replace(/[^a-zA-Z0-9._-]/gu, "_");
-	return path.join(CACHE_DIR, `${safeKey}-${hashCacheKeyParts(key)}.json`);
-};
-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}`;
-};
-var getCachedJson = async (key) => {
-	await ensureCacheDir();
-	const filePath = toCachePath(key);
-	const file = Bun.file(filePath);
-	if (!await file.exists()) return null;
-	let parsed;
-	try {
-		parsed = await file.json();
-	} catch {
-		await rm(filePath, { force: true });
-		return null;
-	}
-	if (parsed && typeof parsed === "object" && "version" in parsed && parsed.version === CACHE_ENVELOPE_VERSION && "value" in parsed) return parsed.value;
-	await rm(filePath, { force: true });
-	return null;
-};
-var setCachedJson = async (key, value) => {
-	await ensureCacheDir();
-	const filePath = toCachePath(key);
-	const tempPath = `${filePath}.${randomUUID()}.tmp`;
-	const envelope = {
-		value,
-		version: CACHE_ENVELOPE_VERSION
-	};
-	await Bun.write(tempPath, JSON.stringify(envelope));
-	await rename(tempPath, filePath);
-};
-var withCachedJson = async (key, loader) => {
-	const filePath = toCachePath(key);
-	const existedBeforeRead = await Bun.file(filePath).exists();
-	const cached = await getCachedJson(key);
-	if (cached !== null || existedBeforeRead && await Bun.file(filePath).exists()) return cached;
-	const value = await loader();
-	await setCachedJson(key, value);
-	return value;
-};
-var invalidateCacheByPrefix = async (...prefixes) => {
-	await ensureCacheDir();
-	const entries = await readdir(CACHE_DIR);
-	await Promise.all(entries.filter((entry) => prefixes.some((prefix) => entry.startsWith(prefix))).map((entry) => rm(path.join(CACHE_DIR, entry), { force: true })));
-};
-//#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) => {
-	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
-	};
-};
-var getCachedThreadTranscriptPreview = async (sessionFile, options = {}) => {
-	const threshold = options.largeTranscriptThresholdBytes ?? 104857600;
-	const previewEventLimit = options.previewEventLimit ?? 200;
-	const fingerprint = await getFileFingerprint(sessionFile);
-	const { fileSizeBytes, shouldDeferTranscriptLoad } = await getThreadRolloutLoadState(sessionFile, threshold);
-	return withCachedJson(`thread-preview-${hashCacheKeyParts(path.basename(sessionFile), fingerprint, String(threshold), String(previewEventLimit))}`, async () => {
-		if (!shouldDeferTranscriptLoad) return parseCodexTranscriptFile(sessionFile, { sourceFileSizeBytes: fileSizeBytes });
-		return parseCodexTranscriptFile(sessionFile, {
-			includeRaw: false,
-			maxEvents: previewEventLimit,
-			maxTurnContexts: 0,
-			sourceFileSizeBytes: fileSizeBytes
-		});
-	});
-};
-//#endregion
-//#region ../../src/lib/sqlite-retry.ts
-var DEFAULT_RETRY_DELAYS_MS = [
-	40,
-	120,
-	250
-];
-var SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
-var sleepSync = (delayMs) => {
-	if (delayMs <= 0) return;
-	Atomics.wait(SLEEP_BUFFER, 0, 0, delayMs);
-};
-var toRetryExhaustedError = (attemptCount, error) => {
-	const message = error instanceof Error ? error.message : String(error);
-	return new Error(`SQLite operation failed after ${attemptCount} attempts: ${message}`, { cause: error });
-};
-var shouldRetrySqliteError = (error, attempt, delaysMs) => {
-	return isRetryableSqliteError(error) && attempt < delaysMs.length;
-};
-var runWithSqliteRetry = ({ action, delaysMs = DEFAULT_RETRY_DELAYS_MS, sleep = sleepSync }) => {
-	let attempt = 0;
-	while (true) try {
-		return action();
-	} catch (error) {
-		if (!shouldRetrySqliteError(error, attempt, delaysMs)) {
-			if (isRetryableSqliteError(error)) throw toRetryExhaustedError(attempt + 1, error);
-			throw error;
-		}
-		sleep(delaysMs[attempt] ?? 0);
-		attempt += 1;
-	}
-};
-//#endregion
-//#region ../../src/lib/codex-browser-db.ts
-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));
-	return chunks;
-};
-var isPromiseLike = (value) => {
-	if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
-	return "then" in value && typeof value.then === "function";
-};
-var openReadonlyDb = (dbPath) => {
-	const db = new Database(dbPath, { readonly: true });
-	try {
-		db.query("SELECT name FROM sqlite_master LIMIT 1").get();
-		return db;
-	} catch (error) {
-		db.close();
-		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);
-	try {
-		db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
-		return db;
-	} catch (error) {
-		db.close();
-		throw error;
-	}
-};
-var toTimestampMs = (thread) => {
-	return thread.updated_at_ms ?? thread.updated_at * 1e3;
-};
-var parseDynamicToolRow = (row) => {
-	return {
-		deferLoading: Number(row.defer_loading ?? 0) === 1,
-		description: String(row.description ?? ""),
-		inputSchema: parseJsonSafely$1(typeof row.input_schema === "string" ? row.input_schema : null),
-		name: String(row.name ?? "unknown"),
-		namespace: typeof row.namespace === "string" ? row.namespace : null,
-		position: Number(row.position ?? 0),
-		threadId: String(row.thread_id)
-	};
-};
-var parseJsonSafely$1 = (value) => {
-	if (!value) return null;
-	try {
-		return JSON.parse(value);
-	} catch {
-		return null;
-	}
-};
-var withReadonlyDb = (dbPath, callback) => {
-	return runWithSqliteRetry({ action: () => {
-		const db = openReadonlyDb(dbPath);
-		try {
-			const result = callback(db);
-			if (isPromiseLike(result)) throw new Error("Database callbacks must be synchronous");
-			return result;
-		} finally {
-			db.close();
-		}
-	} });
-};
-var withWritableDb = (dbPath, callback) => {
-	const db = runWithSqliteRetry({ action: () => {
-		return openWritableDb(dbPath, 5e3);
-	} });
-	try {
-		const result = callback(db);
-		if (isPromiseLike(result)) throw new Error("Database callbacks must be synchronous");
-		return result;
-	} finally {
-		db.close();
-	}
-};
-var resolveCodexThreadDbPath = () => {
-	const configuredDbPath = process.env.SPIRACHA_CODEX_DB?.trim();
-	if (configuredDbPath) return configuredDbPath;
-	const candidates = [
-		DEFAULT_DB_PATH,
-		path.join(DEFAULT_CODEX_DIR, "sqlite", "state_5.sqlite"),
-		path.join(os.homedir(), ".codex", "state_5.sqlite")
-	];
-	for (const candidate of candidates) try {
-		if (!statSync(candidate).isFile()) continue;
-		return candidate;
-	} catch {}
-	throw new Error(`Unable to open Codex thread database. Tried: ${candidates.join(", ")}`);
-};
-var readAllThreads = (dbPath) => {
-	return withReadonlyDb(dbPath, (db) => {
-		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);
-};
-var buildProjectSummaryMap = (threads) => {
-	const projectMap = /* @__PURE__ */ new Map();
-	for (const thread of threads) {
-		const projectName = getPortablePathBasename(thread.cwd);
-		if (!projectName) continue;
-		const current = projectMap.get(projectName) ?? {
-			archivedThreadCount: 0,
-			cwdPaths: /* @__PURE__ */ new Set(),
-			lastUpdatedAtMs: null,
-			modelNames: /* @__PURE__ */ new Set(),
-			name: projectName,
-			threadCount: 0,
-			totalTokens: 0
-		};
-		current.archivedThreadCount += thread.archived ? 1 : 0;
-		current.cwdPaths.add(thread.cwd);
-		current.lastUpdatedAtMs = Math.max(current.lastUpdatedAtMs ?? 0, toTimestampMs(thread));
-		if (thread.model) current.modelNames.add(thread.model);
-		current.threadCount += 1;
-		current.totalTokens += thread.tokens_used;
-		projectMap.set(projectName, current);
-	}
-	return projectMap;
-};
-var mapProjectSummaries = (projectMap) => {
-	return [...projectMap.values()].map((project) => {
-		return {
-			archivedThreadCount: project.archivedThreadCount,
-			cwdPaths: [...project.cwdPaths].sort(),
-			lastUpdatedAtMs: project.lastUpdatedAtMs,
-			modelNames: [...project.modelNames].sort(),
-			name: project.name,
-			threadCount: project.threadCount,
-			totalTokens: project.totalTokens
-		};
-	}).sort((left, right) => {
-		if (left.totalTokens !== right.totalTokens) return right.totalTokens - left.totalTokens;
-		return left.name.localeCompare(right.name);
-	});
-};
-var getRelationsForThread = (db, threadId, existingTableNames) => {
-	if (!existingTableNames.has("thread_spawn_edges")) return {
-		childEdges: [],
-		parentThreadId: null
-	};
-	const parentRow = db.query("SELECT parent_thread_id, child_thread_id, status FROM thread_spawn_edges WHERE child_thread_id = ? LIMIT 1").get(threadId);
-	return {
-		childEdges: db.query("SELECT parent_thread_id, child_thread_id, status FROM thread_spawn_edges WHERE parent_thread_id = ? ORDER BY child_thread_id ASC").all(threadId),
-		parentThreadId: parentRow?.parent_thread_id ?? null
-	};
-};
-var getExistingTableNames = (db) => {
-	const rows = db.query("SELECT name FROM sqlite_master WHERE type = ?").all("table");
-	return new Set(rows.map((row) => row.name));
-};
-var getThreadDeleteTargets = (db, threadIds) => {
-	if (threadIds.length === 0) return [];
-	const targets = [];
-	for (const threadIdChunk of chunkValues(threadIds, SQLITE_DELETE_BATCH_SIZE)) {
-		const placeholders = threadIdChunk.map(() => "?").join(", ");
-		targets.push(...db.query(`SELECT id, rollout_path FROM threads WHERE id IN (${placeholders})`).all(...threadIdChunk));
-	}
-	return targets;
-};
-var deleteThreadIds = (db, threadIds) => {
-	if (threadIds.length === 0) return {
-		deletedSessionFiles: [],
-		deletedThreadIds: []
-	};
-	const existingTableNames = getExistingTableNames(db);
-	const threadTargets = getThreadDeleteTargets(db, threadIds);
-	const existingIds = threadTargets.map((target) => target.id);
-	if (existingIds.length === 0) return {
-		deletedSessionFiles: [],
-		deletedThreadIds: []
-	};
-	db.transaction((ids) => {
-		for (const threadIdChunk of chunkValues(ids, SQLITE_DELETE_BATCH_SIZE)) {
-			const placeholders = threadIdChunk.map(() => "?").join(", ");
-			if (existingTableNames.has("thread_dynamic_tools")) db.query(`DELETE FROM thread_dynamic_tools WHERE thread_id IN (${placeholders})`).run(...threadIdChunk);
-			if (existingTableNames.has("thread_goals")) db.query(`DELETE FROM thread_goals WHERE thread_id IN (${placeholders})`).run(...threadIdChunk);
-			if (existingTableNames.has("stage1_outputs")) db.query(`DELETE FROM stage1_outputs WHERE thread_id IN (${placeholders})`).run(...threadIdChunk);
-			if (existingTableNames.has("thread_spawn_edges")) db.query(`DELETE FROM thread_spawn_edges WHERE parent_thread_id IN (${placeholders}) OR child_thread_id IN (${placeholders})`).run(...threadIdChunk, ...threadIdChunk);
-			db.query(`DELETE FROM threads WHERE id IN (${placeholders})`).run(...threadIdChunk);
-		}
-	})(existingIds);
-	return {
-		deletedSessionFiles: threadTargets.map((target) => target.rollout_path),
-		deletedThreadIds: existingIds
-	};
-};
-var deleteThreadSessionFiles = async (sessionFiles) => {
-	const uniqueSessionFiles = [...new Set(sessionFiles)];
-	await mapWithConcurrency(uniqueSessionFiles, SESSION_FILE_DELETE_CONCURRENCY, async (sessionFile) => {
-		await rm(sessionFile, { force: true });
-		return sessionFile;
-	});
-	return uniqueSessionFiles;
-};
-var listCodexProjects = (dbPath) => {
-	return mapProjectSummaries(buildProjectSummaryMap(applyRolloutActivityTimestamps(mergeFallbackThreadRows(dbPath, readAllThreads(dbPath)))));
-};
-var compactThreadListRow = (thread) => {
-	return {
-		...thread,
-		preview: cleanInlineTitle(thread.preview || thread.first_user_message || ""),
-		title: cleanInlineTitle(thread.title)
-	};
-};
-var listProjectThreads = async (dbPath, projectName, options = {}) => {
-	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,
-			stats: {
-				deferred: true,
-				execCommandCount: 0,
-				toolCallCount: 0,
-				webSearchEventCount: 0
-			},
-			thread: compactThreadListRow(thread)
-		};
-		const transcript = await getCachedParsedCodexTranscript(thread.rollout_path);
-		return {
-			project: projectName,
-			rolloutSizeBytes: rollout.fileSizeBytes,
-			stats: {
-				deferred: false,
-				execCommandCount: transcript.stats.execCommandCount,
-				toolCallCount: transcript.stats.toolCallCount,
-				webSearchEventCount: transcript.stats.webSearchEventCount
-			},
-			thread: compactThreadListRow(thread)
-		};
-	})).sort((left, right) => toTimestampMs(right.thread) - toTimestampMs(left.thread));
-};
-var getThreadBrowseData = (dbPath, threadId) => {
-	return withReadonlyDb(dbPath, (db) => {
-		const existingTableNames = getExistingTableNames(db);
-		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: (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
-		};
-	});
-};
-var getCodexDashboardSummary = (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;
-		const rows = db.query("SELECT parent_thread_id, child_thread_id FROM thread_spawn_edges").all();
-		return new Set(rows.flatMap((row) => [row.parent_thread_id, row.child_thread_id])).size;
-	});
-	return {
-		activeThreads: threads.filter((thread) => !thread.archived).length,
-		archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
-		recentThreads: buildDashboardRecentThreads(threads),
-		threadsWithRelations,
-		topProjectsByThreadCount: [...projects].sort((left, right) => {
-			if (left.threadCount !== right.threadCount) return right.threadCount - left.threadCount;
-			return left.name.localeCompare(right.name);
-		}).slice(0, 5),
-		topProjectsByTokens: projects.slice(0, 5),
-		totalProjects: projects.length,
-		totalThreads: threads.length,
-		totalTokens: threads.reduce((sum, thread) => sum + thread.tokens_used, 0)
-	};
-};
-var deleteCodexThread = async (dbPath, threadId, options = {}) => {
-	const result = withWritableDb(dbPath, (db) => {
-		return deleteThreadIds(db, [threadId]);
-	});
-	try {
-		if (options.deleteSessionFiles) return {
-			...result,
-			deletedSessionFiles: await deleteThreadSessionFiles(result.deletedSessionFiles)
-		};
-		return {
-			...result,
-			deletedSessionFiles: []
-		};
-	} finally {
-		await invalidateCodexUiCaches();
-	}
-};
-var deleteCodexThreads = async (dbPath, threadIds, options = {}) => {
-	const result = withWritableDb(dbPath, (db) => {
-		return deleteThreadIds(db, threadIds);
-	});
-	try {
-		if (options.deleteSessionFiles) return {
-			...result,
-			deletedSessionFiles: await deleteThreadSessionFiles(result.deletedSessionFiles)
-		};
-		return {
-			...result,
-			deletedSessionFiles: []
-		};
-	} finally {
-		await invalidateCodexUiCaches();
-	}
-};
-var deleteCodexProject = async (dbPath, projectName, options = {}) => {
-	const result = withWritableDb(dbPath, (db) => {
-		return {
-			...deleteThreadIds(db, db.query("SELECT id, cwd FROM threads").all().filter((thread) => getPortablePathBasename(thread.cwd) === projectName).map((thread) => thread.id)),
-			projectName
-		};
-	});
-	try {
-		if (options.deleteSessionFiles) return {
-			...result,
-			deletedSessionFiles: await deleteThreadSessionFiles(result.deletedSessionFiles)
-		};
-		return {
-			...result,
-			deletedSessionFiles: []
-		};
-	} finally {
-		await invalidateCodexUiCaches();
-	}
-};
-var listScopedThreads = (dbPath, projectName) => {
-	return mergeFallbackThreadRows(dbPath, filterThreadsByProject(readAllThreads(dbPath), projectName), projectName);
-};
-var invalidateCodexUiCaches = async () => {
-	await invalidateCacheByPrefix("analytics-", "thread-");
-};
-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));
-};
-var incrementCount = (counts, key) => {
-	counts.set(key, (counts.get(key) ?? 0) + 1);
-};
-var toDistribution = (counts) => {
-	return [...counts.entries()].map(([label, count]) => ({
-		count,
-		label
-	})).sort((left, right) => {
-		if (left.count !== right.count) return right.count - left.count;
-		return left.label.localeCompare(right.label);
-	});
-};
-var buildModelsByTokens = (threads) => {
-	const models = /* @__PURE__ */ new Map();
-	for (const thread of threads) {
-		const model = thread.model ?? "unknown";
-		const current = models.get(model) ?? {
-			threadCount: 0,
-			totalTokens: 0
-		};
-		current.threadCount += 1;
-		current.totalTokens += thread.tokens_used;
-		models.set(model, current);
-	}
-	return [...models.entries()].map(([model, value]) => ({
-		model,
-		...value
-	})).sort((left, right) => {
-		if (left.totalTokens !== right.totalTokens) return right.totalTokens - left.totalTokens;
-		return left.model.localeCompare(right.model);
-	});
-};
-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 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();
-	let threadsWithWebSearch = 0;
-	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),
-		summary: {
-			archivedThreads: threads.filter((thread) => Boolean(thread.archived)).length,
-			averageTokensPerThread: threads.length === 0 ? 0 : roundToTwoDecimals(totalTokens / threads.length),
-			distinctToolNames: toolUsage.size,
-			threadsWithWebSearch,
-			totalProjects: projectNames.size,
-			totalThreads: threads.length,
-			totalTokens
-		},
-		toolUsage: toDistribution(toolUsage).map((item) => ({
-			count: item.count,
-			name: item.label
-		}))
-	};
-};
-var getCodexAnalytics = async (input) => {
-	const threads = listScopedThreads(input.dbPath, input.project);
-	return withCachedJson(buildCodexAnalyticsCacheKey(input.dbPath, threads, input.project), async () => computeCodexAnalyticsFromThreads(threads, { transcriptConcurrency: input.transcriptConcurrency }));
-};
-//#endregion
-//#region ../../src/lib/codex-exporter-db.ts
-var matchesFilters = (value, options) => {
-	return matchesCwdFilter(value, options.cwdFilter) && matchesProjectFilter(value, options.projectFilter);
-};
-var toCodexRelativePath = (targetPath) => {
-	const codexRoot = path.resolve(DEFAULT_CODEX_DIR);
-	const normalized = path.resolve(targetPath);
-	if (normalized.startsWith(`${codexRoot}${path.sep}`)) return path.relative(codexRoot, normalized);
-	return normalized;
-};
-var matchesCwdFilter = (value, cwdFilter) => {
-	if (!cwdFilter) return true;
-	return value === cwdFilter;
-};
-var matchesProjectFilter = (value, projectFilter) => {
-	if (!projectFilter) return true;
-	if (!value) return false;
-	return getPortablePathBasename(value) === projectFilter;
-};
-//#endregion
-//#region ../../src/lib/codex-exporter-transcript.ts
-var convertSessionFile = async (target, options) => {
-	let transcriptState;
-	try {
-		transcriptState = await collectCodexTranscript(target.sessionFile, options, target.thread?.model ?? null);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to read Codex transcript ${target.sessionFile}: ${message}`);
-	}
-	if (!matchesFilters(target.thread?.cwd ?? transcriptState.sessionMeta.cwd ?? null, options)) return null;
-	if (transcriptState.sections.length === 0) return null;
-	return [
-		renderDocumentTitle(getTitle(target, transcriptState.sessionMeta), options.outputFormat),
-		"",
-		options.includeMetadata ? renderMetadataBlock(buildMetadataEntries(target, transcriptState.sessionMeta, options), options.outputFormat) : "",
-		...transcriptState.sections
-	].filter(Boolean).join("\n").trimEnd() + "\n";
-};
-var writeSessionFileExport = async (target, options, outputPath, transform = (text) => text) => {
-	const transcriptOutputPath = `${outputPath}.transcript.tmp`;
-	let transcriptStream = null;
-	const state = {
-		assistantModel: target.thread?.model ?? null,
-		sections: [],
-		sessionMeta: {}
-	};
-	let wroteSection = false;
-	try {
-		transcriptStream = await createExportWriteStream(transcriptOutputPath);
-		for await (const parsed of readJsonlObjects$1(target.sessionFile)) {
-			captureSessionMeta(parsed, state.sessionMeta);
-			const block = renderCodexTranscriptRecord(parsed, options, state);
-			if (!block) continue;
-			transcriptStream.write(transform(wroteSection ? `${getSectionSeparator()}${block}` : block));
-			wroteSection = true;
-		}
-		await finalizeExportWriteStream(transcriptStream);
-		transcriptStream = null;
-		if (!matchesFilters(target.thread?.cwd ?? state.sessionMeta.cwd ?? null, options) || !wroteSection) return false;
-		const outputStream = await createExportWriteStream(outputPath);
-		try {
-			const prefix = buildStreamExportPrefix(target, state.sessionMeta, options);
-			if (prefix) outputStream.write(transform(prefix));
-			const transcriptReadStream = createReadStream(transcriptOutputPath, { encoding: "utf8" });
-			transcriptReadStream.pipe(outputStream, { end: false });
-			await finished(transcriptReadStream);
-			outputStream.write("\n");
-			await finalizeExportWriteStream(outputStream);
-		} catch (error) {
-			outputStream.destroy();
-			throw error;
-		}
-		return true;
-	} catch (error) {
-		if (transcriptStream) transcriptStream.destroy();
-		throw error;
-	} finally {
-		await rm(transcriptOutputPath, { force: true });
-	}
-};
-var collectCodexTranscript = async (sessionFile, options, assistantModel = null) => {
-	const state = {
-		assistantModel,
-		sections: [],
-		sessionMeta: {}
-	};
-	for await (const parsed of readJsonlObjects$1(sessionFile)) processCodexTranscriptRecord(parsed, options, state);
-	return state;
-};
-var getSectionSeparator = () => "\n";
-var processCodexTranscriptRecord = (parsed, options, state) => {
-	captureSessionMeta(parsed, state.sessionMeta);
-	const block = renderCodexTranscriptRecord(parsed, options, state);
-	if (block) state.sections.push(block);
-};
-var renderCodexTranscriptRecord = (parsed, options, state) => {
-	const message = extractMessageRecord(parsed);
-	if (message) return processCodexMessageRecord(message, options, state);
-	if (!options.includeTools) return "";
-	const tool = extractToolRecord(parsed);
-	if (!tool) return "";
-	return renderToolBlock(tool, options.outputFormat);
-};
-var processCodexMessageRecord = (message, options, state) => {
-	return renderMessageBlock(message, options.outputFormat, state.assistantModel, options.includeCommentary);
-};
-var buildStreamExportPrefix = (target, sessionMeta, options) => {
-	if (!options.includeMetadata) return "";
-	return `${[
-		renderDocumentTitle(getTitle(target, sessionMeta), options.outputFormat),
-		"",
-		renderMetadataBlock(buildMetadataEntries(target, sessionMeta, options), options.outputFormat)
-	].filter(Boolean).join("\n")}\n`;
-};
-var formatToolOutputSummary = (outputText, outputFormat) => {
-	if (!outputText) return "";
-	const lines = outputText.split("\n").map((line) => line.trim()).filter(Boolean);
-	if (lines.length === 0) return "";
-	const summaryLines = [];
-	const command = lines.find((line) => line.startsWith("Command: "));
-	const exit = lines.find((line) => line.startsWith("Process exited with code "));
-	const wall = lines.find((line) => line.startsWith("Wall time: "));
-	if (command) summaryLines.push(command);
-	if (exit) summaryLines.push(exit);
-	if (wall) summaryLines.push(wall);
-	if (outputFormat === "md") return summaryLines.map((line) => `*${line}*`).join("\n");
-	return summaryLines.join("\n");
-};
-var parseExecCommandArguments = (argumentsText) => {
-	if (!argumentsText) return {
-		argumentsParseFailed: false,
-		cmd: null,
-		workdir: null
-	};
-	try {
-		const parsed = JSON.parse(argumentsText);
-		return {
-			argumentsParseFailed: false,
-			cmd: typeof parsed.cmd === "string" ? parsed.cmd : null,
-			workdir: typeof parsed.workdir === "string" ? parsed.workdir : null
-		};
-	} catch {
-		return {
-			argumentsParseFailed: true,
-			cmd: null,
-			workdir: null
-		};
-	}
-};
-var getTitle = (target, sessionMeta) => {
-	if (target.thread?.title) return cleanInlineTitle(target.thread.title);
-	return sessionMeta.id ?? path.basename(target.sessionFile, ".jsonl");
-};
-var buildMetadataEntries = (target, sessionMeta, options) => {
-	return [
-		...buildCodexExportIdentityMetadata(target, sessionMeta),
-		...buildCodexExportPathMetadata(target, options),
-		...buildCodexRelationMetadata(target),
-		...buildCodexThreadMetadata(target, sessionMeta),
-		...buildCodexAgentMetadata(target)
-	];
-};
-var buildCodexExportIdentityMetadata = (target, sessionMeta) => {
-	const thread = target.thread;
-	return [
-		{
-			key: "exported_from",
-			value: thread ? "thread_db_and_session_jsonl" : "session_jsonl_fallback"
-		},
-		{
-			key: "fallback_reason",
-			value: target.fallbackReason
-		},
-		{
-			key: "thread_id",
-			value: thread?.id ?? sessionMeta.id ?? null
-		},
-		{
-			key: "title",
-			value: thread?.title || null
-		}
-	];
-};
-var buildCodexExportPathMetadata = (target, options) => {
-	const relativeOutputPath = target.outputRelativePath;
-	return [
-		{
-			key: "source_output_relative_path",
-			value: relativeOutputPath
-		},
-		{
-			key: options.outputFormat === "md" ? "source_markdown_path" : "source_text_path",
-			value: relativeOutputPath
-		},
-		{
-			key: "rollout_path",
-			value: target.sessionFile
-		},
-		{
-			key: "rollout_path_relative_to_codex",
-			value: toCodexRelativePath(target.sessionFile)
-		}
-	];
-};
-var buildCodexRelationMetadata = (target) => {
-	const childThreadIds = target.relations.childEdges.map((edge) => edge.child_thread_id);
-	const childEdges = target.relations.childEdges.map((edge) => ({
-		child_thread_id: edge.child_thread_id,
-		status: edge.status
-	}));
-	return [
-		{
-			key: "parent_thread_id",
-			value: target.relations.parentThreadId
-		},
-		{
-			key: "child_thread_ids",
-			value: childThreadIds
-		},
-		{
-			key: "spawn_edges",
-			value: childEdges
-		}
-	];
-};
-var buildCodexThreadMetadata = (target, sessionMeta) => {
-	return [...buildCodexThreadTimingMetadata(target, sessionMeta), ...buildCodexThreadIdentityMetadata(target, sessionMeta)];
-};
-var buildCodexThreadTimingMetadata = (target, sessionMeta) => {
-	const thread = target.thread;
-	return [
-		{
-			key: "created_at_unix",
-			value: thread?.created_at ?? null
-		},
-		{
-			key: "created_at_iso",
-			value: formatUnixSeconds(thread?.created_at ?? null)
-		},
-		{
-			key: "updated_at_unix",
-			value: thread?.updated_at ?? null
-		},
-		{
-			key: "updated_at_iso",
-			value: formatUnixSeconds(thread?.updated_at ?? null)
-		},
-		{
-			key: "archived_at_unix",
-			value: thread?.archived_at ?? null
-		},
-		{
-			key: "archived_at_iso",
-			value: formatUnixSeconds(thread?.archived_at ?? null)
-		},
-		{
-			key: "session_started_at_iso",
-			value: sessionMeta.timestamp ?? null
-		}
-	];
-};
-var buildCodexThreadIdentityMetadata = (target, sessionMeta) => {
-	const thread = target.thread;
-	return [
-		{
-			key: "archived",
-			value: thread ? Boolean(thread.archived) : null
-		},
-		{
-			key: "source",
-			value: thread?.source ?? sessionMeta.source ?? null
-		},
-		{
-			key: "originator",
-			value: sessionMeta.originator ?? null
-		},
-		{
-			key: "model_provider",
-			value: thread?.model_provider ?? null
-		},
-		{
-			key: "model",
-			value: thread?.model ?? null
-		},
-		{
-			key: "reasoning_effort",
-			value: thread?.reasoning_effort ?? null
-		},
-		{
-			key: "cli_version",
-			value: thread?.cli_version || sessionMeta.cli_version || null
-		},
-		{
-			key: "cwd",
-			value: thread?.cwd || sessionMeta.cwd || null
-		},
-		{
-			key: "approval_mode",
-			value: thread?.approval_mode ?? null
-		},
-		{
-			key: "sandbox_policy",
-			value: parseJsonSafely(thread?.sandbox_policy ?? null)
-		},
-		{
-			key: "memory_mode",
-			value: thread?.memory_mode ?? null
-		},
-		{
-			key: "tokens_used",
-			value: thread?.tokens_used ?? null
-		},
-		{
-			key: "has_user_event",
-			value: thread ? Boolean(thread.has_user_event) : null
-		}
-	];
-};
-var buildCodexAgentMetadata = (target) => {
-	const thread = target.thread;
-	return [
-		{
-			key: "git_sha",
-			value: thread?.git_sha ?? null
-		},
-		{
-			key: "git_branch",
-			value: thread?.git_branch ?? null
-		},
-		{
-			key: "git_origin_url",
-			value: thread?.git_origin_url ?? null
-		},
-		{
-			key: "agent_nickname",
-			value: thread?.agent_nickname ?? null
-		},
-		{
-			key: "agent_role",
-			value: thread?.agent_role ?? null
-		},
-		{
-			key: "agent_path",
-			value: thread?.agent_path ?? null
-		},
-		{
-			key: "first_user_message",
-			value: thread?.first_user_message || null
-		}
-	];
-};
-var parseJsonSafely = (value) => {
-	if (!value) return null;
-	try {
-		return JSON.parse(value);
-	} catch {
-		return value;
-	}
-};
-var formatUnixSeconds = (value) => {
-	if (value === null || value === void 0) return null;
-	return (/* @__PURE__ */ new Date(value * 1e3)).toISOString();
-};
-var captureSessionMeta = (parsed, meta) => {
-	if (parsed.type !== "session_meta") return;
-	const payload = asObject(parsed.payload);
-	if (!payload) return;
-	meta.id = asString(payload.id) ?? meta.id;
-	meta.timestamp = asString(payload.timestamp) ?? meta.timestamp;
-	meta.cwd = asString(payload.cwd) ?? meta.cwd;
-	meta.source = asString(payload.source) ?? meta.source;
-	meta.originator = asString(payload.originator) ?? meta.originator;
-	meta.cli_version = asString(payload.cli_version) ?? meta.cli_version;
-};
-var extractMessageRecord = (parsed) => {
-	if (parsed.type === "message") {
-		const directMessage = normalizeMessage(parsed);
-		if (directMessage) return directMessage;
-	}
-	if (parsed.type !== "response_item") return null;
-	const payload = asObject(parsed.payload);
-	if (!payload) return null;
-	if (payload.type !== "message" && payload.type !== "agent_message" && payload.type !== "user_message") return null;
-	return normalizeMessage(payload);
-};
-var normalizeMessage = (value) => {
-	const type = asString(value.type);
-	const role = asString(value.role) ?? (type === "agent_message" ? "assistant" : type === "user_message" ? "user" : null);
-	const content = value.content ?? asString(value.message);
-	const phase = asString(value.phase);
-	if (!role || content === void 0) return null;
-	return {
-		content,
-		model: asString(value.model),
-		phase: phase ?? void 0,
-		role
-	};
-};
-var extractToolRecord = (parsed) => {
-	if (parsed.type !== "response_item") return null;
-	const payload = asObject(parsed.payload);
-	if (!payload) return null;
-	if (payload.type === "function_call") {
-		const name = asString(payload.name);
-		const argumentsText = asString(payload.arguments);
-		const callId = asString(payload.call_id);
-		if (name !== "exec_command") return null;
-		return {
-			argumentsText: argumentsText ?? void 0,
-			callId,
-			kind: "call",
-			name
-		};
-	}
-	if (payload.type === "function_call_output") {
-		const callId = asString(payload.call_id);
-		const outputText = asString(payload.output);
-		if (!outputText?.includes("Command: ")) return null;
-		return {
-			callId,
-			kind: "output",
-			name: "function_call_output",
-			outputText: outputText ?? void 0
-		};
-	}
-	return null;
-};
-var renderMessageBlock = (message, outputFormat, assistantModel, includeCommentary) => {
-	if (message.role !== "user" && message.role !== "assistant") return "";
-	if (message.role === "assistant" && message.phase === "commentary" && !includeCommentary) return "";
-	const text = cleanExtractedText(stripPreviewBlock(extractText(message.content))).trim();
-	if (!text || shouldSkipMessage(message.role, text)) return "";
-	return renderSection(message.role === "user" ? "User" : formatModelLabel(message.model ?? assistantModel), message.phase ? `Phase: ${message.phase}\n\n${text}` : text, outputFormat);
-};
-var renderToolBlock = (tool, outputFormat) => {
-	if (tool.kind === "call") {
-		const details = formatToolCallDetails(tool, outputFormat);
-		return details ? renderSection("Tool", details, outputFormat) : "";
-	}
-	const summary = formatToolOutputSummary(tool.outputText ?? "", outputFormat);
-	return summary ? renderSection("Tool Output", summary, outputFormat) : "";
-};
-var stripPreviewBlock = (text) => {
-	const parts = text.split(/\n{2,}/).map((part) => part.trim()).filter(Boolean);
-	if (parts.length < 2) return text.trim();
-	const first = parts[0];
-	const second = parts[1];
-	const isTranscriptHeading = (value) => /^##\s+.+$/i.test(value);
-	if (!(!/^([UA]):/i.test(first) && !isTranscriptHeading(first) && /^([UA]):/i.test(second) === false && isTranscriptHeading(second))) return text.trim();
-	return parts.slice(1).join("\n\n");
-};
-var shouldSkipMessage = (role, text) => {
-	if (text.startsWith("<environment_context>")) return true;
-	if (text.startsWith("AGENTS.md instructions for ")) return true;
-	if (text.startsWith("# AGENTS.md instructions for ")) return true;
-	if (role === "user" && text.includes("<environment_context>")) return true;
-	return false;
-};
-var formatToolCallDetails = (tool, outputFormat) => {
-	if (tool.name !== "exec_command") return "";
-	const details = parseExecCommandArguments(tool.argumentsText);
-	return details.cmd ? `Command: ${formatInlineLiteral(details.cmd, outputFormat)}` : "";
-};
-var extractText = (content) => {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) return content.map((item) => extractContentPart(item)).filter((part) => part.length > 0).join("\n\n");
-	if (content && typeof content === "object") {
-		const text = asString(content.text);
-		if (text) return text;
-	}
-	return "";
-};
-var extractContentPart = (value) => {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return "";
-	const item = value;
-	const type = asString(item.type);
-	const text = asString(item.text);
-	if ((type === "input_text" || type === "output_text" || type === "text") && text) return text;
-	if (type === "input_image") return "[Image attached]";
-	return text ?? "";
-};
-//#endregion
-//#region ../../src/lib/codex-browser-export.ts
-var LARGE_BROWSER_EXPORT_THRESHOLD_BYTES = 128 * 1024 * 1024;
-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 `${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 `${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`);
-};
-var buildUniqueBatchEntryBaseName = (baseName, threadId, usedBaseNames) => {
-	if (!usedBaseNames.has(baseName)) {
-		usedBaseNames.add(baseName);
-		return baseName;
-	}
-	const collisionSafeBaseName = `${baseName}-${threadId}`;
-	usedBaseNames.add(collisionSafeBaseName);
-	return collisionSafeBaseName;
-};
-var toDownloadOptions = (input) => {
-	return {
-		cwdFilter: null,
-		dbPath: input.dbPath,
-		flat: false,
-		includeCommentary: input.includeCommentary,
-		includeMetadata: input.includeMetadata,
-		includeTools: input.includeTools,
-		inputDir: "",
-		outputDir: "",
-		outputFormat: input.outputFormat,
-		projectFilter: null,
-		threadIds: [input.threadId]
-	};
-};
-var resolvePublicExportDir = async (publicExportDir) => {
-	if (publicExportDir) {
-		await ensureDirectory(publicExportDir);
-		return publicExportDir;
-	}
-	return ensureUiExportDir();
-};
-var ensureDirectory = async (directoryPath) => {
-	await mkdir(directoryPath, { recursive: true });
-};
-var createExportWorkspace = async (exportDir, exportBaseName) => {
-	return mkdtemp(path.join(exportDir, `${exportBaseName}-`));
-};
-var getRolloutSnapshot = async (rolloutPath) => {
-	const metadata = await stat(rolloutPath);
-	return {
-		mtimeMs: metadata.mtimeMs,
-		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, 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,
-		threadId
-	});
-};
-var cleanupExportWorkspace = async (workspacePath) => {
-	try {
-		await rm(workspacePath, {
-			force: true,
-			recursive: true
-		});
-	} catch (error) {
-		logExportEvent("warn", "workspace_cleanup_failed", {
-			error: error instanceof Error ? error.message : String(error),
-			workspacePath
-		});
-	}
-};
-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 = getExportMimeType(input.outputFormat);
-	const transform = (text) => input.pathDisplaySettings ? applyPathTransforms(text, {
-		...input.pathDisplaySettings,
-		projectPath: browseData.thread.cwd
-	}) : text;
-	const rolloutSnapshotBefore = await getExistingRolloutSnapshot(input.threadId, browseData.thread.rollout_path);
-	logExportEvent("info", "single_start", {
-		fileName,
-		sizeBytes: rolloutSnapshotBefore.sizeBytes,
-		threadId: input.threadId
-	});
-	try {
-		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);
-			const savedPath = path.join(workspaceDir, `${exportBaseName}.${extension}`);
-			const zipPath = buildUniqueArchivePath(exportDir, exportBaseName);
-			try {
-				if (!await writeSessionFileExport({
-					fallbackReason: null,
-					outputRelativePath: fileName,
-					relations: browseData.relations,
-					sessionFile: browseData.thread.rollout_path,
-					thread: browseData.thread
-				}, toDownloadOptions(input), savedPath, transform)) throw new Error(`Thread ${input.threadId} produced no exportable content`);
-				await zipExportFile(savedPath, zipPath);
-			} finally {
-				await cleanupExportWorkspace(workspaceDir);
-			}
-			const rolloutSnapshotAfter = await getRolloutSnapshot(browseData.thread.rollout_path);
-			logRolloutChangeIfDetected(input.threadId, rolloutSnapshotBefore, rolloutSnapshotAfter);
-			const zipStat = await Bun.file(zipPath).stat();
-			logExportEvent("info", "single_zip_ready", {
-				downloadUrl: buildUiExportDownloadUrl(zipPath),
-				durationMs: Date.now() - startedAt,
-				fileName: `${exportBaseName}.zip`,
-				sizeBytes: zipStat.size,
-				threadId: input.threadId,
-				zipPath
-			});
-			return {
-				downloadUrl: buildUiExportDownloadUrl(zipPath),
-				fileName: `${exportBaseName}.zip`,
-				mimeType: "application/zip",
-				mode: "download_url"
-			};
-		}
-		const content = await convertSessionFile({
-			fallbackReason: null,
-			outputRelativePath: fileName,
-			relations: browseData.relations,
-			sessionFile: browseData.thread.rollout_path,
-			thread: browseData.thread
-		}, 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, rolloutSnapshotBefore, rolloutSnapshotAfter);
-		logExportEvent("info", "single_inline_ready", {
-			durationMs: Date.now() - startedAt,
-			fileName,
-			sizeBytes: content.length,
-			threadId: input.threadId
-		});
-		return {
-			content: transform(content),
-			fileName,
-			mimeType,
-			mode: "download"
-		};
-	} catch (error) {
-		logExportEvent("error", "single_error", {
-			error: error instanceof Error ? error.message : String(error),
-			fileName,
-			threadId: input.threadId
-		});
-		throw error;
-	}
-};
-var renderCodexThreadsDownload = async (input) => {
-	const startedAt = Date.now();
-	const threadIds = [...new Set(input.threadIds)];
-	if (threadIds.length === 0) throw new Error("No threads selected for export");
-	const browseEntries = threadIds.map((threadId) => getThreadBrowseData(input.dbPath, threadId));
-	const threads = browseEntries.map((entry) => entry.thread);
-	const exportDir = await resolvePublicExportDir(input.publicExportDir);
-	const exportBaseName = buildBatchExportBaseName(threads);
-	const bundleDirectory = await createExportWorkspace(exportDir, exportBaseName);
-	const zipPath = buildUniqueArchivePath(exportDir, exportBaseName);
-	const usedBatchEntryBaseNames = /* @__PURE__ */ new Set();
-	logExportEvent("info", "batch_start", {
-		exportBaseName,
-		selectedThreadCount: threadIds.length,
-		selectedThreadIds: threadIds,
-		zipPath
-	});
-	try {
-		for (const entry of browseEntries) {
-			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"}`;
-			const savedPath = path.join(bundleDirectory, relativeFileName);
-			const transform = (text) => input.pathDisplaySettings ? applyPathTransforms(text, {
-				...input.pathDisplaySettings,
-				projectPath: entry.thread.cwd
-			}) : text;
-			if (uniqueBaseName !== singleBaseName) logExportEvent("warn", "batch_entry_name_collision", {
-				resolvedFileName: relativeFileName,
-				singleBaseName,
-				threadId: entry.thread.id
-			});
-			if (!await writeSessionFileExport({
-				fallbackReason: null,
-				outputRelativePath: relativeFileName,
-				relations: entry.relations,
-				sessionFile: entry.thread.rollout_path,
-				thread: entry.thread
-			}, {
-				...toDownloadOptions({
-					...input,
-					threadId: entry.thread.id
-				}),
-				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, rolloutSnapshotBefore, rolloutSnapshotAfter);
-		}
-		await zipExportDirectory(bundleDirectory, zipPath);
-	} catch (error) {
-		logExportEvent("error", "batch_error", {
-			error: error instanceof Error ? error.message : String(error),
-			exportBaseName,
-			selectedThreadCount: threadIds.length,
-			selectedThreadIds: threadIds,
-			zipPath
-		});
-		throw error;
-	} finally {
-		await cleanupExportWorkspace(bundleDirectory);
-	}
-	const zipStat = await Bun.file(zipPath).stat();
-	logExportEvent("info", "batch_ready", {
-		downloadUrl: buildUiExportDownloadUrl(zipPath),
-		durationMs: Date.now() - startedAt,
-		fileName: `${exportBaseName}.zip`,
-		selectedThreadCount: threadIds.length,
-		selectedThreadIds: threadIds,
-		sizeBytes: zipStat.size,
-		zipPath
-	});
-	return {
-		downloadUrl: buildUiExportDownloadUrl(zipPath),
-		fileName: `${exportBaseName}.zip`,
-		mimeType: "application/zip",
-		mode: "download_url"
-	};
-};
-//#endregion
-//#region ../../src/lib/codex-thread-recovery.ts
-var backupFile = async (filePath, label) => {
-	const backupPath = `${filePath}.bak-${label}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "").replace(/\.\d{3}Z$/, "Z").replace("T", "-")}`;
-	await copyFile(filePath, backupPath);
-	return backupPath;
-};
-var resolveCodexDirFromDbPath = (dbPath) => {
-	const dbDir = path.dirname(dbPath);
-	return path.basename(dbDir) === "sqlite" ? path.dirname(dbDir) : dbDir;
-};
-var assertRequiredStatePath = async (filePath) => {
-	if (!await Bun.file(filePath).exists()) throw new Error(`Required Codex state file not found: ${filePath}`);
-};
-var readGlobalState = async (globalStatePath) => {
-	return await Bun.file(globalStatePath).json();
-};
-var writeGlobalState = async (globalStatePath, state) => {
-	await Bun.write(globalStatePath, JSON.stringify(state));
-};
-var updateGlobalRoots = (state, projectCwds) => {
-	const savedRoots = state["electron-saved-workspace-roots"] ?? [];
-	const projectOrder = state["project-order"] ?? [];
-	const missingSaved = projectCwds.filter((cwd) => !savedRoots.includes(cwd));
-	const missingProjectOrder = projectCwds.filter((cwd) => !projectOrder.includes(cwd));
-	if (missingSaved.length === 0 && missingProjectOrder.length === 0) return {
-		projectRootsAdded: 0,
-		savedRootsAdded: 0,
-		state
-	};
-	state["electron-saved-workspace-roots"] = [...savedRoots, ...missingSaved];
-	state["project-order"] = [...projectOrder, ...missingProjectOrder];
-	return {
-		projectRootsAdded: missingProjectOrder.length,
-		savedRootsAdded: missingSaved.length,
-		state
-	};
-};
-var getProjectTopLevelThreads = (db, projectName) => {
-	return db.query("SELECT id, cwd, rollout_path, thread_source FROM threads WHERE archived = 0").all().filter((thread) => {
-		return getPortablePathBasename(thread.cwd) === projectName && thread.thread_source !== "subagent";
-	});
-};
-var refreshThreadRows = (db, threadIds) => {
-	if (threadIds.length === 0) return 0;
-	const nowSeconds = Math.floor(Date.now() / 1e3);
-	const nowMs = Date.now();
-	const placeholders = threadIds.map(() => "?").join(", ");
-	const result = db.prepare(`
-        UPDATE threads
-        SET updated_at = ?1,
-            updated_at_ms = ?2,
-            has_user_event = 1
-        WHERE id IN (${placeholders})
-    `).run(nowSeconds, nowMs, ...threadIds);
-	return Number(result.changes);
-};
-var refreshSessionIndex = async (sessionIndexPath, threadIds) => {
-	if (threadIds.length === 0) return 0;
-	const now = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-	const threadIdSet = new Set(threadIds);
-	const lines = (await Bun.file(sessionIndexPath).text()).split("\n");
-	let updated = 0;
-	const rewrittenLines = [];
-	for (const line of lines) {
-		if (!line.trim()) continue;
-		const parsed = JSON.parse(line);
-		if (parsed.id && threadIdSet.has(parsed.id)) {
-			parsed.updated_at = now;
-			updated += 1;
-		}
-		rewrittenLines.push(JSON.stringify(parsed));
-	}
-	await Bun.write(sessionIndexPath, `${rewrittenLines.join("\n")}\n`);
-	return updated;
-};
-var touchRolloutFiles = async (codexDir, rolloutPaths) => {
-	const now = /* @__PURE__ */ new Date();
-	let touched = 0;
-	for (const rolloutPath of rolloutPaths) {
-		const absolutePath = path.isAbsolute(rolloutPath) ? rolloutPath : path.join(codexDir, rolloutPath);
-		if (!await Bun.file(absolutePath).exists()) continue;
-		await utimes(absolutePath, now, now);
-		touched += 1;
-	}
-	return touched;
-};
-var recoverCodexProjectThreads = async (dbPath, projectName) => {
-	const codexDir = resolveCodexDirFromDbPath(dbPath);
-	const globalStatePath = path.join(codexDir, ".codex-global-state.json");
-	const sessionIndexPath = path.join(codexDir, "session_index.jsonl");
-	await assertRequiredStatePath(dbPath);
-	await assertRequiredStatePath(globalStatePath);
-	await assertRequiredStatePath(sessionIndexPath);
-	const backups = {
-		globalState: await backupFile(globalStatePath, "recover-project-roots"),
-		sessionIndex: await backupFile(sessionIndexPath, "recover-project-session-index"),
-		stateDb: await backupFile(dbPath, "recover-project-threads")
-	};
-	const globalState = await readGlobalState(globalStatePath);
-	const db = runWithSqliteRetry({ action: () => {
-		const opened = new Database(dbPath);
-		opened.exec("PRAGMA busy_timeout = 5000");
-		return opened;
-	} });
-	try {
-		const topLevelThreads = getProjectTopLevelThreads(db, projectName);
-		const projectCwds = [...new Set(topLevelThreads.map((thread) => thread.cwd))];
-		const rootUpdateResult = updateGlobalRoots(globalState, projectCwds);
-		await writeGlobalState(globalStatePath, rootUpdateResult.state);
-		const threadIds = topLevelThreads.map((thread) => thread.id);
-		const rolloutPaths = topLevelThreads.map((thread) => thread.rollout_path);
-		const threadDbRowsUpdated = refreshThreadRows(db, threadIds);
-		const sessionIndexRowsUpdated = await refreshSessionIndex(sessionIndexPath, threadIds);
-		const rolloutFilesTouched = await touchRolloutFiles(codexDir, rolloutPaths);
-		return {
-			backups,
-			projectName,
-			projectRootsAdded: rootUpdateResult.projectRootsAdded,
-			resolvedCwds: projectCwds,
-			rolloutFilesTouched,
-			savedRootsAdded: rootUpdateResult.savedRootsAdded,
-			sessionIndexRowsUpdated,
-			threadDbRowsUpdated,
-			topLevelThreadsFound: threadIds.length
-		};
-	} finally {
-		db.close();
-	}
-};
-//#endregion
-//#region src/lib/codex-server.ts?tss-serverfn-split
-var projectSchema = z.object({ project: z.string().min(1) });
-var deleteProjectSchema = z.object({
-	deleteSessionFiles: z.boolean().default(false),
-	project: z.string().min(1)
-});
-var threadSchema = z.object({ threadId: z.string().min(1) });
-var deleteThreadSchema = z.object({
-	deleteSessionFiles: z.boolean().default(false),
-	threadId: z.string().min(1)
-});
-var deleteThreadsSchema = z.object({
-	deleteSessionFiles: z.boolean().default(false),
-	threadIds: z.array(z.string().min(1)).min(1)
-});
-var analyticsSchema = z.object({ project: z.string().min(1).nullable() });
-var exportSchema = z.object({
-	convertToProjectRoot: z.boolean(),
-	includeCommentary: z.boolean(),
-	includeMetadata: z.boolean(),
-	includeTools: z.boolean(),
-	outputFormat: z.enum(["md", "txt"]),
-	redactUsername: z.boolean(),
-	threadId: z.string().min(1),
-	zipArchive: z.boolean().default(false)
-});
-var exportThreadsSchema = z.object({
-	convertToProjectRoot: z.boolean(),
-	includeCommentary: z.boolean(),
-	includeMetadata: z.boolean(),
-	includeTools: z.boolean(),
-	outputFormat: z.enum(["md", "txt"]),
-	redactUsername: z.boolean(),
-	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) => {
-	return error instanceof Error && /ENOENT|no such file/i.test(error.message);
-};
-var getDashboardSummaryFn_createServerFn_handler = createServerRpc({
-	id: "792690638a3b10035a5b7368c3d98bdc70cbfe1e36a4aa5f45b1c49b8b1025b0",
-	name: "getDashboardSummaryFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => getDashboardSummaryFn.__executeServer(opts));
-var getDashboardSummaryFn = createServerFn({ method: "GET" }).handler(getDashboardSummaryFn_createServerFn_handler, async () => {
-	return getCodexDashboardSummary(getDbPath());
-});
-var listProjectsFn_createServerFn_handler = createServerRpc({
-	id: "ccefccb816ba13508f23db4e31067b3403e750225257592d3ae11071ffc3fd6f",
-	name: "listProjectsFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => listProjectsFn.__executeServer(opts));
-var listProjectsFn = createServerFn({ method: "GET" }).handler(listProjectsFn_createServerFn_handler, async () => {
-	return listCodexProjects(getDbPath());
-});
-var listProjectThreadsFn_createServerFn_handler = createServerRpc({
-	id: "59fb2cb4d60c8e7d47e0afcc914ee6f9d9f4bf076c8e66eab1693066753655b3",
-	name: "listProjectThreadsFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => listProjectThreadsFn.__executeServer(opts));
-var listProjectThreadsFn = createServerFn({ method: "GET" }).validator(projectSchema).handler(listProjectThreadsFn_createServerFn_handler, async ({ data }) => {
-	return listProjectThreads(getDbPath(), data.project);
-});
-var getThreadSnapshotFn_createServerFn_handler = createServerRpc({
-	id: "72991e2b6e0adbf8d63bb8b139dad88a00b77b7030ec28ceac36c3cce7846b4c",
-	name: "getThreadSnapshotFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => getThreadSnapshotFn.__executeServer(opts));
-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;
-	let transcriptState = rollout.shouldDeferTranscriptLoad ? "deferred" : "available";
-	if (!rollout.shouldDeferTranscriptLoad) try {
-		transcript = await getCachedParsedCodexTranscript(browseData.thread.rollout_path);
-	} catch (error) {
-		if (!isMissingFileError(error)) throw error;
-		transcriptState = "missing";
-	}
-	return {
-		...browseData,
-		availableTools: browseData.dynamicTools.length > 0 ? browseData.dynamicTools : transcript?.sessionMeta.dynamicTools ?? [],
-		rollout,
-		transcript,
-		transcriptState
-	};
-});
-var getThreadTranscriptFn_createServerFn_handler = createServerRpc({
-	id: "5da27045f7e28ded6353bc16aace284af7ef1b4010ef04d0186a6feadb466497",
-	name: "getThreadTranscriptFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => getThreadTranscriptFn.__executeServer(opts));
-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({
-	id: "4712520da0f07bbd1f0907e5a162fe518516ff4caca3fd23876cc65539d87d7a",
-	name: "getAnalyticsFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => getAnalyticsFn.__executeServer(opts));
-var getAnalyticsFn = createServerFn({ method: "GET" }).validator(analyticsSchema).handler(getAnalyticsFn_createServerFn_handler, async ({ data }) => {
-	return getCodexAnalytics({
-		dbPath: getDbPath(),
-		project: data.project
-	});
-});
-var exportThreadFn_createServerFn_handler = createServerRpc({
-	id: "0814663c3bdc58135f97d210d145ef0be5ca54ef9a5f1e3030be9b1bfc901e30",
-	name: "exportThreadFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => exportThreadFn.__executeServer(opts));
-var exportThreadFn = createServerFn({ method: "POST" }).validator(exportSchema).handler(exportThreadFn_createServerFn_handler, async ({ data }) => {
-	return renderCodexThreadDownload({
-		dbPath: getDbPath(),
-		includeCommentary: data.includeCommentary,
-		includeMetadata: data.includeMetadata,
-		includeTools: data.includeTools,
-		outputFormat: data.outputFormat,
-		pathDisplaySettings: {
-			convertToProjectRoot: data.convertToProjectRoot,
-			redactUsername: data.redactUsername
-		},
-		threadId: data.threadId,
-		zipArchive: data.zipArchive
-	});
-});
-var exportThreadsFn_createServerFn_handler = createServerRpc({
-	id: "b4e15c006e9a277470958bb008f89b5b0acc7256109581de44cf17d587d174a5",
-	name: "exportThreadsFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => exportThreadsFn.__executeServer(opts));
-var exportThreadsFn = createServerFn({ method: "POST" }).validator(exportThreadsSchema).handler(exportThreadsFn_createServerFn_handler, async ({ data }) => {
-	return renderCodexThreadsDownload({
-		dbPath: getDbPath(),
-		includeCommentary: data.includeCommentary,
-		includeMetadata: data.includeMetadata,
-		includeTools: data.includeTools,
-		outputFormat: data.outputFormat,
-		pathDisplaySettings: {
-			convertToProjectRoot: data.convertToProjectRoot,
-			redactUsername: data.redactUsername
-		},
-		threadIds: data.threadIds,
-		zipArchive: data.zipArchive
-	});
-});
-var deleteThreadFn_createServerFn_handler = createServerRpc({
-	id: "29727b7ad5b8fe42e83817376653e064d9fe8888799f056b2e59296b3396568b",
-	name: "deleteThreadFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => deleteThreadFn.__executeServer(opts));
-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({
-	id: "96aa60bf7dd9b5bde415bcf3ad6f6955a975eecd9aa0516cf401cc39bebebe6c",
-	name: "deleteThreadsFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => deleteThreadsFn.__executeServer(opts));
-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({
-	id: "164ee82cdd565ed96591a64312f0f7bd961040baf066a89d9f5636330d11360b",
-	name: "deleteProjectFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => deleteProjectFn.__executeServer(opts));
-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({
-	id: "412c05e00aef3ad43905593fdfd2f566561259da7e1f5d6f1c03428ff33c6867",
-	name: "recoverProjectThreadsFn",
-	filename: "src/lib/codex-server.ts"
-}, (opts) => recoverProjectThreadsFn.__executeServer(opts));
-var recoverProjectThreadsFn = createServerFn({ method: "POST" }).validator(projectSchema).handler(recoverProjectThreadsFn_createServerFn_handler, async ({ data }) => {
-	return recoverCodexProjectThreads(getDbPath(), data.project);
-});
-//#endregion
-export { deleteProjectFn_createServerFn_handler, deleteThreadFn_createServerFn_handler, deleteThreadsFn_createServerFn_handler, exportThreadFn_createServerFn_handler, exportThreadsFn_createServerFn_handler, getAnalyticsFn_createServerFn_handler, getDashboardSummaryFn_createServerFn_handler, getThreadSnapshotFn_createServerFn_handler, getThreadTranscriptFn_createServerFn_handler, listProjectThreadsFn_createServerFn_handler, listProjectsFn_createServerFn_handler, recoverProjectThreadsFn_createServerFn_handler };