Skip to content

A one-of-a-kind resume builder that keeps your privacy in mind. Completely secure, customizable, portable, open-source and free forever. Try it out today!

25.5 KB
Raw Blame
import type { Proposal, ProposalApplications } from "@reactive-resume/resume/proposals";
import type { CoverLetterDraftVersion, CoverLetter } from "@reactive-resume/schema/cover-letter/data";
import { t } from "@lingui/core/macro";
import { ORPCError } from "@orpc/client";
import { isEqual } from "es-toolkit";
import { create } from "zustand/react";
import {
	acknowledgeProposalApplications,
	appliedApplications,
	queueProposalApplications,
	readProposalApplications,
	restoreProposalApplications,
	proposalAiOperationIds,
} from "@reactive-resume/resume/proposals";
import {
	coverLetterDocumentSchema,
	coverLetterDraftVersionSchema,
	coverLetterSchema,
} from "@reactive-resume/schema/cover-letter/data";
import { generateId } from "@reactive-resume/utils/string";
import { getAccountGeneration, getAccountId } from "@/libs/auth/account-scope";
import { client, streamClient } from "@/libs/orpc/client";

type LetterMetadata = CoverLetter["style"]["metadata"];

/**
 * What's typed in the letter editor: saved once typing pauses. `metadata` is the letter's own type, colors and page;
 * setting it ends the design link.
 */
export type LetterEdits = Partial<
	Pick<
		CoverLetter,
		| "name"
		| "recipient"
		| "content"
		| "greeting"
		| "signOff"
		| "recipientName"
		| "recipientCompany"
		| "letterDate"
		| "aiOperationIds"
	>
> & {
	/** The letter's own sender details, all of them editable once the sender link is off. */
	sender?: Partial<CoverLetter["style"]["basics"] & { picture: Pick<CoverLetter["style"]["picture"], "hidden"> }>;
	/** The letter language stays independent from its linked design. */
	locale?: string;
	metadata?: Partial<Pick<LetterMetadata, "typography" | "design" | "page">>;
};

const mergeEdits = (edits: LetterEdits, next: LetterEdits): LetterEdits => ({
	...edits,
	...next,
	...(edits.metadata && next.metadata ? { metadata: { ...edits.metadata, ...next.metadata } } : {}),
	...(edits.sender && next.sender ? { sender: { ...edits.sender, ...next.sender } } : {}),
});

const applyEdits = (letter: CoverLetter, { metadata, sender, locale, ...fields }: LetterEdits): CoverLetter => ({
	...letter,
	...fields,
	...(fields.aiOperationIds && !isEqual(fields.aiOperationIds, letter.aiOperationIds ?? []) ? { aiUsage: null } : {}),
	...(metadata ? { designLinked: false } : {}),
	style: {
		...letter.style,
		...(metadata ? { metadata: { ...letter.style.metadata, ...metadata } } : {}),
		...(locale
			? {
					metadata: {
						...letter.style.metadata,
						...metadata,
						page: { ...(metadata?.page ?? letter.style.metadata.page), locale },
					},
				}
			: {}),
		...(sender ? senderStyle(letter.style, sender) : {}),
	},
});

function senderStyle(style: CoverLetter["style"], { picture, ...basics }: NonNullable<LetterEdits["sender"]>) {
	return {
		basics: { ...style.basics, ...basics },
		picture: picture ? { ...style.picture, ...picture } : style.picture,
	};
}

/** `conflict`: the letter changed somewhere else, so saving stops until it's reloaded. */
type LetterSaveStatus = "saved" | "saving" | "error" | "conflict";

/**
 * A draft from the posting, kept apart from the letter: streaming, ready to keep, or failed. The body changes only
 * when a draft is kept, so a failed or discarded draft leaves the letter as it was.
 */
export type LetterDraft =
	| { phase: "idle" }
	/**
	 * `versions` are the earlier finished drafts, oldest first, so Shorter or More personal never loses one.
	 * `stopped` marks text Stop cut short.
	 */
	| {
			phase: "streaming" | "ready";
			text: string;
			aiOperationIds: string[];
			versions: CoverLetterDraftVersion[];
			stopped?: true;
	  }
	| { phase: "failed"; provider: string | null; error: unknown; versions: CoverLetterDraftVersion[] };

/** The most drafts kept side by side: the current one and up to four before it. */
const MAX_DRAFT_VERSIONS = 5;

const SAVE_DELAY_MS = 800;

type LetterEditorStore = {
	proposalApplications: ProposalApplications;
	pendingProposalApplications: ProposalApplications;
	/**
	 * Set while the edits are this app's own: it applies assistant edits only through checked decisions. Edits restored
	 * from an older app's recovery lack it and are sent without proposalSafety until the server takes them or the letter
	 * is reloaded, so updating the app never vouches for what the older one queued.
	 */
	proposalSafety?: "v1" | undefined;
	letter: CoverLetter | null;
	/** The server's name, kept apart from optimistic edits for the browser title. */
	savedName: string | null;
	status: LetterSaveStatus;
	/** Sender editing pauses while a link, restore, template change or recovery replaces server state. */
	changing: boolean;
	/** Edits not sent yet; they stay on top of whatever the server returns. */
	pending: LetterEdits;
	/** One editing visit: its saves share one History version. */
	sessionId: string;
	draft: LetterDraft;
	load: (letter: CoverLetter, options?: { recover?: boolean }) => void;
	edit: (
		edits: LetterEdits,
		options?: {
			applied?: readonly Pick<Proposal, "id" | "after" | "snapshot" | "aiOperationIds">[];
			restoreApplications?: ProposalApplications;
		},
	) => void;
	/** Saves everything typed so far. False on failure; edits remain for retry. */
	flush: () => Promise<boolean>;
	/**
	 * Saves what's pending, then makes a change that returns the letter (a link, a template, a restore). Throws what
	 * the change throws, so the caller can say what went wrong.
	 */
	change: (action: (letter: CoverLetter) => Promise<CoverLetter>) => Promise<CoverLetter>;
	/** Keeps conflicting edits as a standalone letter before replacing this visit with the saved version. */
	reloadFromServer: () => Promise<CoverLetter | null>;
	reset: () => void;
};

const idleDraft: LetterDraft = { phase: "idle" };

const draftKey = (id: string) => `letter-draft:${getAccountId() ?? "signed-out"}:${id}`;
type StoredDraft = {
	text: string;
	versions?: CoverLetterDraftVersion[];
	aiOperationIds?: string[];
	variant: "draft" | "shorter" | "personal";
	revision: number;
	stopped?: true;
};

/** An unkept draft survives a same-tab reload with Keep/Discard, so it never costs a second paid request. */
function readStoredDraft(id: string, revision: number): LetterDraft | null {
	try {
		const value = JSON.parse(sessionStorage.getItem(draftKey(id)) ?? "null") as
			| (Omit<StoredDraft, "versions"> & { versions?: unknown[]; versionAiOperationIds?: unknown[] })
			| null;
		if (!value || typeof value.text !== "string" || !value.text.trim() || value.revision !== revision) return null;
		const versions = Array.isArray(value.versions)
			? value.versions
					.flatMap((version, index) => {
						const parsed = coverLetterDraftVersionSchema.safeParse(
							typeof version === "string"
								? { text: version, aiOperationIds: value.versionAiOperationIds?.[index] }
								: version,
						);
						return parsed.success ? [parsed.data] : [];
					})
					.slice(-4)
			: [];
		return {
			phase: "ready",
			text: value.text,
			aiOperationIds: coverLetterDraftVersionSchema.parse({ text: value.text, aiOperationIds: value.aiOperationIds })
				.aiOperationIds,
			versions,
			...(value.stopped ? { stopped: true as const } : {}),
		};
	} catch {
		return null;
	}
}

function writeStoredDraft(id: string, draft: StoredDraft) {
	try {
		// Keep text-only versions readable by older app bundles.
		sessionStorage.setItem(
			draftKey(id),
			JSON.stringify({
				...draft,
				versions: draft.versions?.map((version) => version.text),
				versionAiOperationIds: draft.versions?.map((version) => version.aiOperationIds),
			}),
		);
	} catch {
		// Blocked storage leaves the draft in this view; only a reload loses it.
	}
}

function clearStoredLetterDraft(id: string) {
	try {
		sessionStorage.removeItem(draftKey(id));
	} catch {
		// Nothing to clear.
	}
}

let timer: ReturnType<typeof setTimeout> | undefined;
let inflight: Promise<void> | null = null;
let drafting: AbortController | null = null;

const recoveryEditsSchema = coverLetterSchema
	.pick({
		name: true,
		recipient: true,
		content: true,
		aiOperationIds: true,
		greeting: true,
		signOff: true,
		recipientName: true,
		recipientCompany: true,
		letterDate: true,
	})
	.partial()
	.extend({
		locale: coverLetterSchema.shape.style.shape.metadata.shape.page.shape.locale.optional(),
		sender: coverLetterSchema.shape.style.shape.basics
			.extend({ picture: coverLetterSchema.shape.style.shape.picture.pick({ hidden: true }) })
			.partial()
			.optional(),
		metadata: coverLetterSchema.shape.style.shape.metadata
			.pick({ typography: true, design: true, page: true })
			.partial()
			.optional(),
	});

type LetterRecovery = {
	letter: CoverLetter;
	pending: LetterEdits;
	proposalApplications: ProposalApplications;
	pendingProposalApplications: ProposalApplications;
	proposalSafety?: unknown;
	storedAt: number;
	key: string;
	raw: string;
};
const RECOVERY_PREFIX = "reactive-resume:unsaved:letter:";
let restoredRecovery: { key: string; raw: string } | undefined;
let savingEdits: { sessionId: string; pending: LetterEdits } | null = null;
let recoveryCopy: { sessionId: string; letter: CoverLetter; copy: CoverLetter } | undefined;

function readRecovery(id: string): LetterRecovery | undefined {
	try {
		let latest: LetterRecovery | undefined;
		for (const key of Object.keys(window.localStorage)) {
			if (!key.startsWith(`${RECOVERY_PREFIX}${id}:`)) continue;
			try {
				const raw = window.localStorage.getItem(key) ?? "null";
				const value = JSON.parse(raw) as LetterRecovery;
				if (
					!Number.isFinite(value?.storedAt) ||
					(Date.now() - value.storedAt > 7 * 86_400_000 &&
						Object.keys(readProposalApplications(value.pendingProposalApplications)).length === 0)
				) {
					window.localStorage.removeItem(key);
					continue;
				}
				const letter = coverLetterSchema.parse({
					...value.letter,
					createdAt: new Date(value.letter.createdAt),
					updatedAt: new Date(value.letter.updatedAt),
				});
				const pending: LetterEdits = Object.fromEntries(
					Object.entries(recoveryEditsSchema.parse(value.pending)).filter(
						([key, parsed]) => Object.hasOwn(value.pending, key) && parsed !== undefined,
					),
				);
				const dirty =
					hasEdits(pending) || Object.keys(readProposalApplications(value.pendingProposalApplications)).length > 0;
				const latestDirty =
					latest && (hasEdits(latest.pending) || Object.keys(latest.pendingProposalApplications).length > 0);
				if (
					letter.id !== id ||
					(latest && ((latestDirty && !dirty) || (Boolean(latestDirty) === dirty && latest.storedAt > value.storedAt)))
				)
					continue;
				latest = {
					...value,
					key,
					raw,
					letter,
					pending,
					proposalApplications: readProposalApplications(value.proposalApplications),
					pendingProposalApplications: readProposalApplications(value.pendingProposalApplications),
				};
			} catch {
				/* Invalid recovery data never replaces a server document. */
			}
		}
		return latest;
	} catch {
		return undefined;
	}
}

/** The autosave owner retains authored edits and unsynchronized decisions in one recovery record. */
function persistRecovery() {
	const state = useLetterEditorStore.getState();
	if (!state.letter) return;
	const pending = mergeEdits(savingEdits?.sessionId === state.sessionId ? savingEdits.pending : {}, state.pending);
	try {
		const key = `${RECOVERY_PREFIX}${state.letter.id}:${state.sessionId}`;
		if (!hasEdits(pending) && Object.keys(state.proposalApplications).length === 0) window.localStorage.removeItem(key);
		else
			window.localStorage.setItem(
				key,
				JSON.stringify({
					letter: state.letter,
					pending,
					proposalApplications: state.proposalApplications,
					pendingProposalApplications: state.pendingProposalApplications,
					proposalSafety: state.proposalSafety,
					storedAt: Date.now(),
				}),
			);
		if (
			!hasEdits(pending) &&
			Object.keys(state.pendingProposalApplications).length === 0 &&
			restoredRecovery &&
			restoredRecovery.key !== key &&
			window.localStorage.getItem(restoredRecovery.key) === restoredRecovery.raw
		)
			window.localStorage.removeItem(restoredRecovery.key);
	} catch {
		/* Full or blocked storage never discards the in-memory edits; autosave can still retry. */
	}
}

const hasEdits = (edits: LetterEdits) => Object.keys(edits).length > 0;

export const useLetterEditorStore = create<LetterEditorStore>()((set, get) => ({
	proposalApplications: {},
	pendingProposalApplications: {},
	proposalSafety: "v1",
	letter: null,
	savedName: null,
	status: "saved",
	changing: false,
	pending: {},
	sessionId: generateId(),
	draft: idleDraft,

	load: (letter, options = {}) => {
		recoveryCopy = undefined;
		if (options.recover === false) {
			// Explicit Reload discards this visit, never another tab's independent recovery entry.
			const current = get();
			try {
				if (current.letter?.id === letter.id)
					window.localStorage.removeItem(`${RECOVERY_PREFIX}${letter.id}:${current.sessionId}`);
				if (
					restoredRecovery?.key.startsWith(`${RECOVERY_PREFIX}${letter.id}:`) &&
					window.localStorage.getItem(restoredRecovery.key) === restoredRecovery.raw
				)
					window.localStorage.removeItem(restoredRecovery.key);
			} catch {
				/* Reload still opens the server document when browser storage is unavailable. */
			}
		} else persistRecovery();
		let recovery = options.recover === false ? undefined : readRecovery(letter.id);
		if (
			recovery &&
			Object.keys(recovery.pendingProposalApplications).length === 0 &&
			isEqual(applyEdits(letter, recovery.pending), letter)
		)
			recovery = { ...recovery, pending: {} };
		if (
			recovery &&
			!hasEdits(recovery.pending) &&
			Object.keys(recovery.pendingProposalApplications).length === 0 &&
			recovery.letter.revision !== letter.revision
		)
			recovery = undefined;
		restoredRecovery = recovery ? { key: recovery.key, raw: recovery.raw } : undefined;
		const restore =
			recovery && (hasEdits(recovery.pending) || Object.keys(recovery.pendingProposalApplications).length > 0)
				? recovery
				: undefined;
		clearTimeout(timer);
		drafting?.abort();
		drafting = null;
		set({
			proposalApplications: recovery?.proposalApplications ?? {},
			pendingProposalApplications: recovery?.pendingProposalApplications ?? {},
			// What an older app's recovery holds is sent on its terms (see proposalSafety).
			proposalSafety: !restore || restore.proposalSafety === "v1" ? "v1" : undefined,
			letter: restore ? { ...applyEdits(letter, restore.pending), revision: restore.letter.revision } : letter,
			savedName: letter.name,
			status: restore
				? restore.letter.revision !== letter.revision
					? "conflict"
					: "saving"
				: Object.keys(recovery?.pendingProposalApplications ?? {}).length
					? "saving"
					: "saved",
			changing: false,
			pending: restore?.pending ?? {},
			sessionId: generateId(),
			// A ready draft from before a reload is shown again, never re-requested.
			draft: readStoredDraft(letter.id, letter.revision) ?? idleDraft,
		});
		if (restore || Object.keys(get().pendingProposalApplications).length > 0)
			timer = setTimeout(() => void get().flush(), SAVE_DELAY_MS);
	},

	edit: (input, options = {}) => {
		const { letter, changing, proposalApplications, pendingProposalApplications } = get();
		const sources = proposalAiOperationIds(options.applied ?? []);
		const withSources = sources.length
			? {
					...input,
					aiOperationIds: [...new Set([...(input.aiOperationIds ?? letter?.aiOperationIds ?? []), ...sources])],
				}
			: input;
		const { sender, ...otherEdits } = withSources;
		const edits = sender && (changing || (letter?.sourceResumeId && letter.senderLinked)) ? otherEdits : withSources;
		if (!hasEdits(edits) || letter?.isLocked) return;
		set((state) =>
			state.letter
				? {
						letter: applyEdits(state.letter, edits),
						proposalApplications: options.restoreApplications
							? restoreProposalApplications(state.proposalApplications, options.restoreApplications)
							: { ...state.proposalApplications, ...appliedApplications(options.applied ?? []) },
						pending: mergeEdits(state.pending, edits),
						status: state.status === "conflict" ? "conflict" : "saving",
					}
				: state,
		);
		set({
			pendingProposalApplications: queueProposalApplications(
				proposalApplications,
				get().proposalApplications,
				pendingProposalApplications,
			),
		});
		persistRecovery();
		clearTimeout(timer);
		timer = setTimeout(() => void get().flush(), SAVE_DELAY_MS);
	},

	flush: async () => {
		const { sessionId } = get();
		clearTimeout(timer);
		if (inflight) await inflight;
		if (get().sessionId !== sessionId) return false;

		const { letter, pending, status, pendingProposalApplications, proposalSafety } = get();
		if (
			!letter ||
			letter.isLocked ||
			(!hasEdits(pending) && Object.keys(pendingProposalApplications).length === 0) ||
			status === "conflict"
		)
			return status === "saved";
		const current = (state: LetterEditorStore) => state.letter?.id === letter.id && state.sessionId === sessionId;

		savingEdits = { sessionId, pending };
		persistRecovery();
		set({ pending: {}, status: "saving" });
		inflight = (async () => {
			try {
				const saved = await client.coverLetters.update({
					id: letter.id,
					expectedRevision: letter.revision,
					sessionId,
					...(proposalSafety ? { proposalSafety } : {}),
					...pending,
					...(Object.keys(pendingProposalApplications).length
						? { proposalApplications: { ...pendingProposalApplications } }
						: {}),
				});
				// What was typed stays as typed (the server trims and cleans what it stores), and so does anything typed
				// since.
				set((state) =>
					current(state)
						? {
								letter: applyEdits(saved, mergeEdits(pending, state.pending)),
								// The server took what this letter held; what's typed from here on is this app's own.
								proposalSafety: "v1",
								pendingProposalApplications: acknowledgeProposalApplications(
									state.pendingProposalApplications,
									pendingProposalApplications,
								),
								savedName: saved.name,
								status: hasEdits(state.pending) ? "saving" : "saved",
							}
						: state,
				);
			} catch (error) {
				const conflict = error instanceof ORPCError && error.code === "CONFLICT";
				set((state) =>
					current(state)
						? { pending: mergeEdits(pending, state.pending), status: conflict ? "conflict" : "error" }
						: state,
				);
			} finally {
				inflight = null;
				if (savingEdits?.sessionId === sessionId) savingEdits = null;
				if (current(get())) persistRecovery();
			}
		})();
		await inflight;

		// Typed while that save was on its way.
		if (!current(get())) return false;
		if (
			get().status === "saving" &&
			(hasEdits(get().pending) || Object.keys(get().pendingProposalApplications).length > 0)
		)
			return get().flush();
		return get().status === "saved";
	},

	change: async (action) => {
		const { sessionId } = get();
		if (get().changing) throw new Error(t`Couldn't save your changes. Try again before continuing.`);
		set({ changing: true });
		try {
			if (!(await get().flush())) throw new Error(t`Couldn't save your changes. Try again before continuing.`);
			const { letter } = get();
			if (!letter || get().sessionId !== sessionId) throw new Error("No letter is open.");
			const next = await action(letter);
			set((state) =>
				state.letter?.id === letter.id && state.sessionId === sessionId
					? { letter: applyEdits(next, state.pending), savedName: next.name }
					: state,
			);
			return next;
		} finally {
			if (get().sessionId === sessionId) set({ changing: false });
		}
	},

	reloadFromServer: async () => {
		const { letter, sessionId, changing, status } = get();
		if (!letter || changing || status !== "conflict") return null;
		set({ changing: true });
		persistRecovery();
		const current = () => get().sessionId === sessionId;
		const unchanged = () => {
			if (!current()) return false;
			if (get().letter !== letter)
				throw new Error(
					t`Your letter changed while reloading. Your edits are still open. Reload again to keep a new copy.`,
				);
			return true;
		};
		try {
			// A failed read can retry without making another copy of the same draft.
			let copy =
				recoveryCopy?.sessionId === sessionId && recoveryCopy.letter === letter ? recoveryCopy.copy : undefined;
			if (!copy) {
				copy = await client.coverLetters.import({
					...(letter.aiOperationIds ? { aiOperationIds: letter.aiOperationIds } : {}),
					document: coverLetterDocumentSchema.parse({
						...letter,
						format: "reactive-resume-cover-letter",
						version: 1,
						name: t`${letter.name} (mine)`.slice(0, 100),
					}),
				});
				if (current()) recoveryCopy = { sessionId, letter, copy };
			}
			if (!unchanged()) return null;
			const saved = await client.coverLetters.getById({ id: letter.id });
			if (!unchanged()) return null;
			get().load(saved, { recover: false });
			return copy;
		} finally {
			if (current()) set({ changing: false });
		}
	},

	reset: () => {
		recoveryCopy = undefined;
		persistRecovery();
		clearTimeout(timer);
		drafting?.abort();
		drafting = null;
		set({
			proposalApplications: {},
			pendingProposalApplications: {},
			proposalSafety: "v1",
			letter: null,
			savedName: null,
			status: "saved",
			changing: false,
			pending: {},
			sessionId: generateId(),
			draft: idleDraft,
		});
	},
}));

/** Streams a draft from the posting (or a Shorter / More personal revision of `previous`) into `draft`. */
export async function startLetterDraft(
	variant: "draft" | "shorter" | "personal" = "draft",
	previous?: string,
	previousAiOperationIds: string[] = [],
) {
	const { letter, sessionId } = useLetterEditorStore.getState();
	if (!letter) return;
	const account = getAccountGeneration();
	drafting?.abort();
	const controller = new AbortController();
	drafting = controller;
	const current = () =>
		drafting === controller &&
		getAccountGeneration() === account &&
		useLetterEditorStore.getState().sessionId === sessionId;
	let revision = letter.revision;
	// A revision keeps what came before it; the oldest drops off past the limit.
	const before = useLetterEditorStore.getState().draft;
	const versions = (
		before.phase === "ready"
			? [...before.versions, { text: before.text, aiOperationIds: before.aiOperationIds }]
			: before.phase === "idle"
				? []
				: before.versions
	).slice(-(MAX_DRAFT_VERSIONS - 1));
	const setDraft = (draft: LetterDraft) => {
		if (!current()) return;
		useLetterEditorStore.setState({ draft });
		if (draft.phase === "ready")
			writeStoredDraft(letter.id, {
				text: draft.text,
				aiOperationIds: draft.aiOperationIds,
				versions,
				variant,
				revision,
			});
	};
	clearStoredLetterDraft(letter.id);
	let aiOperationIds = variant === "draft" ? [] : previousAiOperationIds;
	setDraft({ phase: "streaming", text: "", aiOperationIds, versions });

	try {
		// Draft from the same saved links and revision the editor shows.
		const saved = await useLetterEditorStore.getState().flush();
		if (!current()) return;
		if (!saved) throw new Error("Save the letter before drafting. Your edits are still here.");
		const savedLetter = useLetterEditorStore.getState().letter;
		if (!savedLetter || savedLetter.id !== letter.id) return;
		revision = savedLetter.revision;
		const stream = await streamClient.coverLetters.draft(
			{ id: letter.id, variant, includeProvenance: true, ...(previous ? { previous } : {}) },
			{ signal: controller.signal },
		);
		let text = "";
		for await (const chunk of stream) {
			if (typeof chunk !== "string") {
				aiOperationIds = [...new Set([...aiOperationIds, chunk.aiOperationId])];
			} else text += chunk;
			setDraft({ phase: "streaming", text, aiOperationIds, versions });
		}
		if (!text.trim()) throw new Error("The draft came back empty.");
		setDraft({ phase: "ready", text: text.trim(), aiOperationIds, versions });
	} catch (error) {
		if (controller.signal.aborted) return;
		const data = error instanceof ORPCError ? (error.data as { provider?: unknown } | undefined) : undefined;
		setDraft({
			phase: "failed",
			provider: typeof data?.provider === "string" ? data.provider : null,
			error,
			versions,
		});
	}
}

/** The draft's earlier version, or nothing: what's left when a run is stopped or its failure dismissed. */
function settleDraft(
	text: string,
	versions: CoverLetterDraftVersion[],
	stopped: boolean,
	aiOperationIds: string[] = [],
): LetterDraft {
	const { letter } = useLetterEditorStore.getState();
	const last = versions.at(-1);
	const draft: LetterDraft = text.trim()
		? { phase: "ready", text: text.trim(), aiOperationIds, versions, ...(stopped ? { stopped: true as const } : {}) }
		: last !== undefined
			? { phase: "ready", ...last, versions: versions.slice(0, -1) }
			: idleDraft;
	if (letter) {
		if (draft.phase === "ready")
			writeStoredDraft(letter.id, {
				text: draft.text,
				aiOperationIds: draft.aiOperationIds,
				versions: draft.versions,
				variant: "draft",
				revision: letter.revision,
				...(draft.stopped ? { stopped: true as const } : {}),
			});
		else clearStoredLetterDraft(letter.id);
	}
	return draft;
}

/** Stops a draft that's streaming and keeps what arrived as a draft to review; with nothing yet, the last version. */
export function stopLetterDraft() {
	const { draft } = useLetterEditorStore.getState();
	drafting?.abort();
	drafting = null;
	if (draft.phase !== "streaming") return;
	useLetterEditorStore.setState({ draft: settleDraft(draft.text, draft.versions, true, draft.aiOperationIds) });
}

/** Closes a failed run, going back to the draft before it when there was one. */
export function dismissLetterDraftFailure() {
	const { draft } = useLetterEditorStore.getState();
	if (draft.phase !== "failed") return;
	useLetterEditorStore.setState({ draft: settleDraft("", draft.versions, false) });
}

export function discardLetterDraft() {
	const id = useLetterEditorStore.getState().letter?.id;
	drafting?.abort();
	drafting = null;
	if (id) clearStoredLetterDraft(id);
	useLetterEditorStore.setState({ draft: idleDraft });
}