spiracha 1.0.0 → 1.1.1

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

@@ -0,0 +1,2062 @@
+import { n as TSS_SERVER_FUNCTION, t as createServerFn } from "../server.js";
+import { t as formatModelLabel$1 } from "./model-label-B1NWGc65.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 { Database } from "bun:sqlite";
+import { mkdir, mkdtemp, readdir, rename, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createReadStream, createWriteStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region ../../node_modules/.bun/@tanstack+start-server-core@1.169.3/node_modules/@tanstack/start-server-core/dist/esm/createServerRpc.js
+var createServerRpc = (serverFnMeta, splitImportFn) => {
+	const url = "/_serverFn/" + serverFnMeta.id;
+	return Object.assign(splitImportFn, {
+		url,
+		serverFnMeta,
+		[TSS_SERVER_FUNCTION]: true
+	});
+};
+//#endregion
+//#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/shared.ts
+var getPortablePathBasename = (value) => {
+	const trimmed = value.replace(/[\\/]+$/u, "");
+	if (!trimmed) return "";
+	return path.win32.basename(path.posix.basename(trimmed));
+};
+var cleanInlineTitle = (value) => {
+	const compact = (value.split("\n").map((line) => line.trim()).find((line) => line.length > 0) ?? "").replace(/\s+/g, " ").trim();
+	if (compact.length <= 160) return compact;
+	return `${compact.slice(0, 157).trimEnd()}...`;
+};
+var cleanExtractedText = (text) => {
+	return text.replace(/^\s*<\/?image>\s*$/gm, "").replace(/\n{3,}/g, "\n\n");
+};
+var formatModelLabel = formatModelLabel$1;
+var asObject = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+};
+var asString = (value) => {
+	return typeof value === "string" ? value : null;
+};
+var asNumber = (value) => {
+	return typeof value === "number" ? value : null;
+};
+var readJsonlObjects = (filePath) => {
+	const stream = createReadStream(filePath, { encoding: "utf8" });
+	const lines = createInterface({
+		crlfDelay: Infinity,
+		input: stream
+	});
+	const lineIterator = lines[Symbol.asyncIterator]();
+	let closed = false;
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		lines.close();
+		stream.destroy();
+	};
+	const readNext = async () => {
+		while (true) {
+			const nextLine = await lineIterator.next();
+			if (nextLine.done) {
+				close();
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+			const trimmed = nextLine.value.trim();
+			if (!trimmed) continue;
+			try {
+				return {
+					done: false,
+					value: JSON.parse(trimmed)
+				};
+			} catch {}
+		}
+	};
+	const iterator = {
+		[Symbol.asyncIterator]: () => iterator,
+		next: async () => readNext(),
+		return: async () => {
+			close();
+			return {
+				done: true,
+				value: void 0
+			};
+		},
+		throw: async (error) => {
+			close();
+			throw error;
+		}
+	};
+	return iterator;
+};
+var renderDocumentTitle = (title, format) => {
+	if (format === "md") return `# ${title}`;
+	return [title, "=".repeat(Math.max(title.length, 3))].join("\n");
+};
+var renderMetadataBlock = (entries, format) => {
+	const filteredEntries = entries.filter((entry) => entry.value !== null && entry.value !== void 0 && entry.value !== "");
+	if (filteredEntries.length === 0) return "";
+	if (format === "md") {
+		const lines = ["---"];
+		for (const entry of filteredEntries) lines.push(`${entry.key}: ${toMetadataValue(entry.value, "md")}`);
+		lines.push("---");
+		return `${lines.join("\n")}\n`;
+	}
+	const lines = ["Metadata", "--------"];
+	for (const entry of filteredEntries) lines.push(`${entry.key}: ${toMetadataValue(entry.value, "txt")}`);
+	return `${lines.join("\n")}\n`;
+};
+var renderSection = (title, body, format) => {
+	const trimmedBody = body.trimEnd();
+	if (!trimmedBody) return "";
+	if (format === "md") return `## ${title}\n\n${trimmedBody}\n`;
+	return `${title}\n${"-".repeat(Math.max(title.length, 3))}\n${trimmedBody}\n`;
+};
+var formatInlineLiteral = (value, format) => {
+	return format === "md" ? inlineCode(value) : value;
+};
+var inlineCode = (value) => {
+	const maxRunLength = (value.match(/`+/g) ?? []).reduce((max, run) => Math.max(max, run.length), 0);
+	const fence = "`".repeat(maxRunLength + 1);
+	return `${fence}${value.startsWith("`") || value.endsWith("`") ? ` ${value} ` : value}${fence}`;
+};
+var createExportWriteStream = async (outputPath) => {
+	await mkdir(path.dirname(outputPath), { recursive: true });
+	return createWriteStream(outputPath, { encoding: "utf8" });
+};
+var finalizeExportWriteStream = async (stream) => {
+	stream.end();
+	await finished(stream);
+};
+var toMetadataValue = (value, format) => {
+	if (Array.isArray(value) || value && typeof value === "object") return JSON.stringify(value);
+	if (typeof value === "string") return format === "md" ? JSON.stringify(value) : value;
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	return format === "md" ? JSON.stringify(String(value)) : String(value);
+};
+//#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(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 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;
+	return parsed;
+};
+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 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);
+	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 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 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) => {
+	const db = new Database(dbPath, { readonly: true });
+	try {
+		db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+};
+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, 5e3);
+		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 {
+		runWithSqliteRetry({ action: () => {
+			return openReadonlyDb(candidate, 1500);
+		} }).close();
+		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 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(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(filterThreadsByProject(readAllThreads(dbPath), projectName), THREAD_LIST_IO_CONCURRENCY, async (thread) => {
+		const rollout = await getThreadRolloutLoadState(thread.rollout_path, options.largeTranscriptThresholdBytes);
+		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 thread = db.query("SELECT * FROM threads WHERE id = ? LIMIT 1").get(threadId);
+		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)),
+			project: getPortablePathBasename(thread.cwd),
+			relations: getRelationsForThread(db, threadId, existingTableNames),
+			thread
+		};
+	});
+};
+var getCodexDashboardSummary = (dbPath) => {
+	const threads = 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: threads.slice(0, 5),
+		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 filterThreadsByProject(readAllThreads(dbPath), projectName);
+};
+var invalidateCodexUiCaches = async () => {
+	await invalidateCacheByPrefix("analytics-", "thread-");
+};
+//#endregion
+//#region ../../src/lib/codex-analytics.ts
+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 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 computeCodexAnalytics = async (threads) => {
+	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);
+	}
+	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(await buildAnalyticsCacheKey(input.dbPath, threads, input.project), async () => computeCodexAnalytics(threads));
+};
+//#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;
+	if (options.optimized) return transcriptState.sections.join("\n\n").trimEnd() + "\n";
+	const title = getTitle(target, transcriptState.sessionMeta);
+	const metadata = buildMetadataEntries(target, transcriptState.sessionMeta, options);
+	return [
+		renderDocumentTitle(title, options.outputFormat),
+		"",
+		renderMetadataBlock(metadata, 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: {},
+		startedTranscript: false
+	};
+	let wroteSection = false;
+	try {
+		transcriptStream = await createExportWriteStream(transcriptOutputPath);
+		for await (const parsed of readJsonlObjects(target.sessionFile)) {
+			captureSessionMeta(parsed, state.sessionMeta);
+			const block = renderCodexTranscriptRecord(parsed, options, state);
+			if (!block) continue;
+			transcriptStream.write(transform(wroteSection ? `${getSectionSeparator(options)}${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: {},
+		startedTranscript: false
+	};
+	for await (const parsed of readJsonlObjects(sessionFile)) processCodexTranscriptRecord(parsed, options, state);
+	return state;
+};
+var getSectionSeparator = (options) => {
+	return options.optimized ? "\n\n" : "\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 options.optimized ? renderCompactToolBlock(tool, options.outputFormat) : renderToolBlock(tool, options.outputFormat);
+};
+var processCodexMessageRecord = (message, options, state) => {
+	if (options.optimized) return processOptimizedCodexMessageRecord(message, options, state);
+	return renderMessageBlock(message, options.outputFormat, state.assistantModel, options.includeCommentary);
+};
+var processOptimizedCodexMessageRecord = (message, options, state) => {
+	if (message.role !== "user" && message.role !== "assistant") return "";
+	if (message.role === "assistant" && message.phase === "commentary" && !options.includeCommentary) return "";
+	const compact = compactMessageText(message, true);
+	if (!compact) return "";
+	if (!state.startedTranscript) {
+		if (shouldSkipOptimizedPrelude(message.role, compact)) return "";
+		state.startedTranscript = true;
+	}
+	return renderCompactBlock(message, compact, options.outputFormat, state.assistantModel);
+};
+var buildStreamExportPrefix = (target, sessionMeta, options) => {
+	if (options.optimized) return "";
+	const title = getTitle(target, sessionMeta);
+	const metadata = buildMetadataEntries(target, sessionMeta, options);
+	return `${[
+		renderDocumentTitle(title, options.outputFormat),
+		"",
+		renderMetadataBlock(metadata, options.outputFormat)
+	].filter(Boolean).join("\n")}\n`;
+};
+var compactMessageText = (message, optimized) => {
+	const cleaned = stripPreviewBlock(extractText(message.content));
+	return optimized ? optimizePlainText(optimizeRenderedText(cleaned)) : cleaned.trim();
+};
+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 shouldSkipOptimizedPrelude = (role, text) => {
+	if (role !== "user") return true;
+	return text.startsWith("AGENTS.md instructions for ") || text.startsWith("# AGENTS.md instructions for ") || text.startsWith("<permissions instructions>") || text.startsWith("<environment_context>") || text.startsWith("<app-context>") || text.startsWith("<collaboration_mode>") || text.startsWith("<skills_instructions>") || text.startsWith("You are Codex, a coding agent based on GPT-5.") || text.startsWith("Read this before making changes.") || text.includes("Filesystem sandboxing defines which files can be read or written.") || text.includes("approval_policy") || text.includes("base_instructions");
+};
+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(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 renderCompactBlock = (message, text, outputFormat, assistantModel) => {
+	const prefix = message.role === "user" ? "U:" : `${formatModelLabel(message.model ?? assistantModel)}:`;
+	const [firstLine, ...rest] = text.split("\n");
+	if (rest.length === 0) return `${prefix} ${normalizeCompactLiteral(firstLine, outputFormat)}`;
+	return [`${prefix} ${normalizeCompactLiteral(firstLine, outputFormat)}`, ...rest.map((line) => normalizeCompactLiteral(line, outputFormat))].join("\n");
+};
+var renderCompactToolBlock = (tool, outputFormat) => {
+	if (tool.kind === "call") {
+		const details = formatCompactToolCall(tool, outputFormat);
+		return details ? `T: ${details}` : "";
+	}
+	const summary = formatCompactToolOutput(tool.outputText ?? "");
+	return summary ? `R: ${summary}` : "";
+};
+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 optimizeRenderedText = (text) => {
+	return text.replace(/^\*Phase:\s+`[^`]+`\*\s*\n*/gm, "").replace(/^\s*<image\b[^>]*>\s*$/gim, "").replace(/^\s*<\/image>\s*$/gim, "").replace(/^\s*\[Image attached\]\s*$/gim, "").replace(/^#{1,6}\s+/gm, "").replace(/^```[^\n]*\n?/gm, "").replace(/\n```$/gm, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/^##\s+User\s*$/gm, "User:").replace(/^##\s+Assistant\s*$/gm, "Assistant:").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*\n]+)\*/g, "$1").replace(/\n{3,}/g, "\n\n").trim();
+};
+var optimizePlainText = (text) => {
+	return text.replace(/\r/g, "").replace(/^\s*<image\b[^>]*>\s*$/gim, "").replace(/^\s*<\/image>\s*$/gim, "").replace(/^\s*\[Image attached\]\s*$/gim, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*\n]+)\*/g, "$1").split("\n").map((line) => line.replace(/[ \t]+$/g, "")).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+};
+var shouldSkipMessage = (role, text) => {
+	if (text.startsWith("<environment_context>")) 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 formatCompactToolCall = (tool, outputFormat) => {
+	if (tool.name === "exec_command") {
+		const details = parseExecCommandArguments(tool.argumentsText);
+		if (!details.cmd) return "exec_command";
+		const command = formatInlineLiteral(details.cmd, outputFormat);
+		return details.workdir ? `exec_command ${command} @ ${details.workdir}` : `exec_command ${command}`;
+	}
+	return tool.callId ? `${tool.name} (${tool.callId})` : tool.name;
+};
+var formatCompactToolOutput = (outputText) => {
+	if (!outputText) return "";
+	const lines = outputText.split("\n").map((line) => line.trim()).filter(Boolean);
+	const exit = lines.find((line) => line.startsWith("Process exited with code "));
+	const wall = lines.find((line) => line.startsWith("Wall time: "));
+	if (exit && wall) return `${exit.replace("Process ", "")}; ${wall.toLowerCase()}`;
+	if (exit) return exit.replace("Process ", "");
+	return "";
+};
+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 ?? "";
+};
+var normalizeCompactLiteral = (value, outputFormat) => {
+	return outputFormat === "md" ? value : value.replace(/`([^`]+)`/g, "$1");
+};
+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)}`;
+};
+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}`;
+};
+var buildUniqueArchivePath = (exportDir, exportBaseName) => {
+	return path.join(exportDir, `${exportBaseName}-${randomUUID()}.zip`);
+};
+var toDownloadOptions = (input) => {
+	return {
+		cwdFilter: null,
+		dbPath: input.dbPath,
+		flat: false,
+		includeCommentary: input.includeCommentary,
+		includeTools: input.includeTools,
+		inputDir: "",
+		optimized: input.optimized,
+		outputDir: "",
+		outputFormat: input.outputFormat,
+		projectFilter: null,
+		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);
+		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 logExportEvent = (level, event, details) => {
+	console[level](`[spiracha:export] ${event}`, details);
+};
+var logRolloutChangeIfDetected = (threadId, rolloutPath, 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
+	});
+};
+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 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 transform = (text) => input.pathDisplaySettings ? applyPathTransforms(text, {
+		...input.pathDisplaySettings,
+		projectPath: browseData.thread.cwd
+	}) : text;
+	const rolloutSnapshotBefore = await getRolloutSnapshot(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)) {
+			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, browseData.thread.rollout_path, 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, browseData.thread.rollout_path, 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);
+	logExportEvent("info", "batch_start", {
+		exportBaseName,
+		selectedThreadCount: threadIds.length,
+		selectedThreadIds: threadIds,
+		zipPath
+	});
+	try {
+		for (const entry of browseEntries) {
+			const rolloutSnapshotBefore = await getRolloutSnapshot(entry.thread.rollout_path);
+			const relativeFileName = `${buildExportBaseName(entry.thread)}.${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 (!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, entry.thread.rollout_path, 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-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(),
+	includeTools: z.boolean(),
+	optimized: z.boolean(),
+	outputFormat: z.enum(["md", "txt"]),
+	redactUsername: z.boolean(),
+	threadId: z.string().min(1)
+});
+var exportThreadsSchema = z.object({
+	convertToProjectRoot: z.boolean(),
+	includeCommentary: z.boolean(),
+	includeTools: z.boolean(),
+	optimized: z.boolean(),
+	outputFormat: z.enum(["md", "txt"]),
+	redactUsername: z.boolean(),
+	threadIds: z.array(z.string().min(1)).min(1)
+});
+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" }).inputValidator(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" }).inputValidator(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" }).inputValidator(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" }).inputValidator(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" }).inputValidator(exportSchema).handler(exportThreadFn_createServerFn_handler, async ({ data }) => {
+	return renderCodexThreadDownload({
+		dbPath: getDbPath(),
+		includeCommentary: data.includeCommentary,
+		includeTools: data.includeTools,
+		optimized: data.optimized,
+		outputFormat: data.outputFormat,
+		pathDisplaySettings: {
+			convertToProjectRoot: data.convertToProjectRoot,
+			redactUsername: data.redactUsername
+		},
+		threadId: data.threadId
+	});
+});
+var exportThreadsFn_createServerFn_handler = createServerRpc({
+	id: "b4e15c006e9a277470958bb008f89b5b0acc7256109581de44cf17d587d174a5",
+	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 }) => {
+	return renderCodexThreadsDownload({
+		dbPath: getDbPath(),
+		includeCommentary: data.includeCommentary,
+		includeTools: data.includeTools,
+		optimized: data.optimized,
+		outputFormat: data.outputFormat,
+		pathDisplaySettings: {
+			convertToProjectRoot: data.convertToProjectRoot,
+			redactUsername: data.redactUsername
+		},
+		threadIds: data.threadIds
+	});
+});
+var deleteThreadFn_createServerFn_handler = createServerRpc({
+	id: "29727b7ad5b8fe42e83817376653e064d9fe8888799f056b2e59296b3396568b",
+	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 }) => {
+	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" }).inputValidator(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" }).inputValidator(deleteProjectSchema).handler(deleteProjectFn_createServerFn_handler, async ({ data }) => {
+	return deleteCodexProject(getDbPath(), data.project, { deleteSessionFiles: data.deleteSessionFiles });
+});
+//#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 };