langcoach 0.1.0 → 0.4.0

package/extension/background.js

@@ -0,0 +1,1584 @@
+import { C as toLocalDate, S as isoWeek, T as emptyState, _ as parseState, b as NotFoundError, c as version, g as isDue, l as DEFAULT_SETTINGS, m as progressOf, p as Coach, r as translationPair, s as suggestThemes, u as isMessage, v as CorruptDataError, y as InvalidDataError } from "./chunks/translate-BpGu9iuQ.js";
+//#region src/shared/dev-hosts.ts
+/**
+* Local hosts the e2e build (and unit tests) accept in place of labs.google. Production builds define
+* `__E2E__` as false, so this folds to an empty list and the host names are compiled out of the bundle
+* (the zip script refuses any bundle that still contains them).
+*/
+var DEV_HOSTNAMES = [];
+/** http(s) URL on one of the dev hosts (always false in production builds). */
+function isDevHostUrl(url) {
+	if (DEV_HOSTNAMES.length === 0) return false;
+	try {
+		const u = new URL(url);
+		return (u.protocol === "http:" || u.protocol === "https:") && DEV_HOSTNAMES.includes(u.hostname);
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/lib/parse.ts
+var isObj$3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? v : void 0;
+var nonEmpty = (v) => {
+	const s = str(v)?.trim();
+	return s ? s : void 0;
+};
+/** Gendered pairs arrive newline-separated; keep them as one entry joined by " / ". */
+var joinLines = (s) => s.split("\n").map((p) => p.trim()).filter(Boolean).join(" / ");
+function header(request) {
+	if (!isObj$3(request)) return null;
+	const sourceLanguage = nonEmpty(request.sourceLanguage);
+	const targetLanguage = nonEmpty(request.targetLanguage);
+	if (!sourceLanguage || !targetLanguage) return null;
+	return {
+		sourceLanguage,
+		targetLanguage,
+		req: request
+	};
+}
+function termItems(list, termKey) {
+	if (!Array.isArray(list)) return [];
+	const out = [];
+	for (const e of list) {
+		if (!isObj$3(e)) continue;
+		const term = joinLines(str(e[termKey]) ?? "");
+		const translation = nonEmpty(e.translation);
+		if (!term || translation === void 0) continue;
+		const pron = joinLines(str(e.transliteration) ?? "");
+		out.push({
+			term,
+			translation,
+			example: "",
+			...pron ? { pronunciation: pron } : {}
+		});
+	}
+	return out;
+}
+function parseInner(kind, requestBody, responseBody) {
+	const h = header(requestBody);
+	if (!h || !isObj$3(responseBody)) return null;
+	const { sourceLanguage, targetLanguage, req } = h;
+	const base = {
+		sourceLanguage,
+		targetLanguage
+	};
+	if (kind === "terms") {
+		const vocab = termItems(responseBody.vocabulary, "term");
+		const phrases = termItems(responseBody.phrases, "phrase");
+		if (!vocab || !phrases) return null;
+		const items = [...vocab, ...phrases];
+		if (items.length === 0) return null;
+		const purpose = nonEmpty(req.purpose);
+		return {
+			lessonKind: "tiny_lesson",
+			...base,
+			...purpose ? { purpose } : {},
+			situation: purpose ?? "Tiny Lesson",
+			items
+		};
+	}
+	if (kind === "grammar") {
+		const rg = responseBody.relevantGrammar;
+		if (!Array.isArray(rg) || rg.length === 0) return null;
+		const grammar = [];
+		for (const g of rg) {
+			if (!isObj$3(g)) continue;
+			const topic = nonEmpty(g.topic);
+			const description = str(g.description);
+			if (!topic || description === void 0 || !Array.isArray(g.examples)) continue;
+			const examples = [];
+			for (const x of g.examples) {
+				if (!isObj$3(x)) continue;
+				const sentence = nonEmpty(x.sentence);
+				const translation = nonEmpty(x.translation);
+				if (!sentence || translation === void 0) continue;
+				const tr = nonEmpty(x.transliteration);
+				const ex = nonEmpty(x.explanation);
+				examples.push({
+					sentence,
+					translation,
+					...tr ? { transliteration: tr } : {},
+					...ex ? { explanation: ex } : {}
+				});
+			}
+			grammar.push({
+				topic,
+				description,
+				examples
+			});
+		}
+		if (grammar.length === 0) return null;
+		const purpose = nonEmpty(req.purpose);
+		return {
+			lessonKind: "grammar",
+			...base,
+			...purpose ? { purpose } : {},
+			situation: purpose ?? "Grammar",
+			items: [],
+			grammar
+		};
+	}
+	if (kind === "conversation") {
+		const context = str(responseBody.context);
+		const dialogue = responseBody.dialogue;
+		if (context === void 0 || !Array.isArray(dialogue) || dialogue.length === 0) return null;
+		const items = [];
+		for (const line of dialogue) {
+			if (!isObj$3(line)) continue;
+			const message = str(line.message);
+			const notes = line.notes;
+			if (message === void 0 || !isObj$3(notes)) continue;
+			const pron = nonEmpty(line.transliteration);
+			for (const [key, expl] of Object.entries(notes)) {
+				const explanation = nonEmpty(expl);
+				if (!key.trim() || explanation === void 0) continue;
+				items.push({
+					term: key,
+					translation: explanation,
+					example: message,
+					...pron ? { pronunciation: pron } : {}
+				});
+			}
+		}
+		if (items.length === 0) return null;
+		return {
+			lessonKind: "slang_hang",
+			...base,
+			situation: Array.from(context).slice(0, 200).join("") || "Slang Hang",
+			items
+		};
+	}
+	const descriptors = responseBody.descriptors;
+	if (!Array.isArray(descriptors) || descriptors.length === 0) return null;
+	const items = [];
+	for (const d of descriptors) {
+		if (!isObj$3(d)) continue;
+		const term = nonEmpty(d.descriptor);
+		const translation = nonEmpty(d.translation);
+		if (!term || translation === void 0) continue;
+		const pron = nonEmpty(d.pronunciation);
+		items.push({
+			term,
+			translation,
+			example: str(d.exampleSentence) ?? "",
+			...pron ? { pronunciation: pron } : {}
+		});
+	}
+	if (items.length === 0) return null;
+	return {
+		lessonKind: "word_cam",
+		...base,
+		situation: nonEmpty(req.object) ?? "Word Cam",
+		items
+	};
+}
+/** Pure; returns null (never throws) on any unexpected shape. */
+function parseCapture(kind, requestBody, responseBody) {
+	try {
+		return parseInner(kind, requestBody, responseBody);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/background/capture.ts
+var LAST_CAPTURE_KEY = "langcoach:lastCapture";
+var PENDING_GRAMMAR_KEY = "langcoach:pendingGrammar";
+function jsonSize(v) {
+	try {
+		return JSON.stringify(v)?.length ?? 0;
+	} catch {
+		return Infinity;
+	}
+}
+var isObj$2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var pairKey = (targetLanguage, purpose) => JSON.stringify([targetLanguage, purpose ?? ""]);
+function asLastCapture(v) {
+	if (!isObj$2(v) || !Array.isArray(v.lessonIds) || typeof v.at !== "string") return null;
+	if (!v.lessonIds.every((x) => typeof x === "string")) return null;
+	return v;
+}
+/** Promise-chain mutex: captures and undos run one at a time (terms and grammar arrive in parallel). */
+function serializer() {
+	let tail = Promise.resolve();
+	return (task) => {
+		const next = tail.then(task, task);
+		tail = next.catch(() => void 0);
+		return next;
+	};
+}
+function createCaptureService(deps) {
+	const { coach, store, area, clock, log } = deps;
+	const run = serializer();
+	/** The translation pair for this capture, or null (no profile, unknown/same native language). */
+	async function nativePair(p, nativeLanguage) {
+		try {
+			const pair = translationPair(p.sourceLanguage, nativeLanguage);
+			if (!pair) return null;
+			const overlay = deps.getShowNativeOnPage ? await deps.getShowNativeOnPage() : true;
+			return {
+				...pair,
+				overlay
+			};
+		} catch (e) {
+			log("LangCoach: native translation hint failed", e);
+			return null;
+		}
+	}
+	/** Card id, term and English meaning of every item of the capture (new or already in the deck). One load. */
+	async function nativeHint(p) {
+		const s = await store.load();
+		const pair = await nativePair(p, s.profile?.nativeLanguage);
+		if (!pair) return void 0;
+		const byKey = new Map(s.cards.map((c) => [c.term.trim().toLocaleLowerCase(), c]));
+		const seen = /* @__PURE__ */ new Set();
+		const items = [];
+		for (const it of p.items) {
+			const card = byKey.get(it.term.trim().toLocaleLowerCase());
+			if (!card || seen.has(card.id)) continue;
+			seen.add(card.id);
+			items.push({
+				cardId: card.id,
+				term: card.term,
+				meaning: card.translation,
+				...card.nativeTranslation ? { native: card.nativeTranslation } : {}
+			});
+		}
+		return items.length ? {
+			...pair,
+			items: items.slice(0, 500)
+		} : void 0;
+	}
+	/** Pending grammar entries that have not expired. */
+	async function readPending(now) {
+		const raw = (await area.get(PENDING_GRAMMAR_KEY))[PENDING_GRAMMAR_KEY];
+		const map = {};
+		let pruned = false;
+		if (isObj$2(raw)) for (const [k, e] of Object.entries(raw)) if (isObj$2(e) && Array.isArray(e.grammar) && typeof e.at === "string" && now - Date.parse(e.at) <= 3e5) map[k] = e;
+		else pruned = true;
+		return {
+			map,
+			pruned
+		};
+	}
+	async function writePending(map) {
+		if (Object.keys(map).length === 0) await area.remove(PENDING_GRAMMAR_KEY);
+		else await area.set({ [PENDING_GRAMMAR_KEY]: map });
+	}
+	async function handleGrammar(p) {
+		const grammar = p.grammar ?? [];
+		const now = clock().getTime();
+		const s = await store.load();
+		let match;
+		for (const l of s.lessons) {
+			const age = now - Date.parse(l.createdAt);
+			if (l.kind === "tiny_lesson" && l.source?.targetLanguage === p.targetLanguage && l.source?.purpose === p.purpose && age >= 0 && age <= 3e5) match = l;
+		}
+		if (match) {
+			const lc = asLastCapture((await area.get(LAST_CAPTURE_KEY))[LAST_CAPTURE_KEY]);
+			const id = lc?.lessonIds.includes(match.id) ? lc.lessonIds[0] : match.id;
+			await coach.attachGrammar(id, grammar);
+			return grammarResult(p, s.profile?.nativeLanguage);
+		}
+		const { map } = await readPending(now);
+		map[pairKey(p.targetLanguage, p.purpose)] = {
+			grammar,
+			at: new Date(now).toISOString()
+		};
+		await writePending(map);
+		return grammarResult(p, s.profile?.nativeLanguage);
+	}
+	async function grammarResult(p, nativeLanguage) {
+		const pair = await nativePair(p, nativeLanguage);
+		const examples = [...new Set((p.grammar ?? []).flatMap((g) => g.examples.map((x) => x.translation.trim()).filter(Boolean)))].slice(0, 100);
+		return pair && pair.overlay && examples.length ? {
+			status: "grammar",
+			native: {
+				...pair,
+				examples
+			}
+		} : { status: "grammar" };
+	}
+	async function saveItems(p, ctx) {
+		const kind = p.lessonKind;
+		const now = clock().getTime();
+		let grammar;
+		let pending;
+		let pendingDirty = false;
+		if (kind === "tiny_lesson") {
+			const r = await readPending(now);
+			pending = r.map;
+			pendingDirty = r.pruned;
+			const key = pairKey(p.targetLanguage, p.purpose);
+			if (pending[key]) {
+				grammar = pending[key].grammar;
+				delete pending[key];
+				pendingDirty = true;
+			}
+		}
+		const source = {
+			app: "lll",
+			targetLanguage: p.targetLanguage,
+			sourceLanguage: p.sourceLanguage,
+			...p.purpose ? { purpose: p.purpose } : {}
+		};
+		const saved = [];
+		try {
+			for (let i = 0; i * 50 < p.items.length; i++) {
+				const items = p.items.slice(i * 50, (i + 1) * 50);
+				const r = await coach.saveLesson({
+					kind,
+					situation: i === 0 ? p.situation : `${p.situation} (${i + 1})`,
+					items,
+					...i === 0 && grammar ? { grammar } : {},
+					source
+				});
+				saved.push({
+					id: r.lesson.id,
+					newCards: r.newCards,
+					duplicates: r.duplicates.length
+				});
+			}
+		} catch (e) {
+			for (const s of saved) try {
+				await coach.undoLesson(s.id);
+			} catch (e2) {
+				log("LangCoach: rollback failed", e2);
+			}
+			throw e;
+		}
+		if (pending && pendingDirty) await writePending(pending);
+		const lessonIds = saved.map((s) => s.id);
+		const newCards = saved.reduce((n, s) => n + s.newCards, 0);
+		const duplicates = saved.reduce((n, s) => n + s.duplicates, 0);
+		let xp = 0;
+		try {
+			xp = (await coach.autoComplete(kind, { lessonId: lessonIds[0] })).xpAwarded;
+		} catch (e) {
+			log("LangCoach: could not record the activity", e);
+		}
+		const lc = {
+			lessonIds,
+			newCards,
+			duplicates,
+			at: new Date(now).toISOString(),
+			tabId: ctx.tabId ?? null
+		};
+		await area.set({ [LAST_CAPTURE_KEY]: lc });
+		let native;
+		try {
+			native = await nativeHint(p);
+		} catch (e) {
+			log("LangCoach: native translation hint failed", e);
+		}
+		return {
+			status: "saved",
+			lessonIds,
+			newCards,
+			duplicates,
+			xp,
+			...native ? { native } : {}
+		};
+	}
+	return {
+		capture(msg, ctx = {}) {
+			if (jsonSize(msg.response) > 2097152) {
+				log(`LangCoach: ignored a ${msg.kind} response larger than 2 MB`);
+				return Promise.resolve(null);
+			}
+			const parsed = parseCapture(msg.kind, msg.request, msg.response);
+			if (parsed && parsed.items.length > 500) {
+				log(`LangCoach: ignored a ${msg.kind} response with more than 500 items`);
+				return Promise.resolve(null);
+			}
+			if (!parsed) {
+				log(`LangCoach: ignored a ${msg.kind} response with an unknown shape`);
+				return Promise.resolve(null);
+			}
+			return run(async () => {
+				try {
+					if (!(await store.load()).profile) await deps.notePendingTarget(parsed.targetLanguage);
+					if (parsed.lessonKind === "grammar") return await handleGrammar(parsed);
+					if (!msg.force && !await deps.getAutoSave()) return {
+						status: "pending",
+						count: parsed.items.length
+					};
+					return await saveItems(parsed, ctx);
+				} catch (e) {
+					log("LangCoach: capture failed", e);
+					throw e;
+				}
+			});
+		},
+		undo(lessonIds) {
+			return run(async () => {
+				const lc = asLastCapture((await area.get(LAST_CAPTURE_KEY))[LAST_CAPTURE_KEY]);
+				const age = lc ? clock().getTime() - Date.parse(lc.at) : NaN;
+				if (!lc || !(age >= 0 && age <= 6e5)) throw new InvalidDataError("Nothing to undo: the last capture is gone or older than 10 minutes");
+				if (!lessonIds.every((id) => lc.lessonIds.includes(id))) throw new InvalidDataError("Only the most recent capture can be undone");
+				let removedCards = 0;
+				for (const id of lessonIds) try {
+					removedCards += (await coach.undoLesson(id)).removedCards;
+				} catch (e) {
+					if (!(e instanceof NotFoundError)) throw e;
+				}
+				const rest = lc.lessonIds.filter((id) => !lessonIds.includes(id));
+				if (rest.length) await area.set({ [LAST_CAPTURE_KEY]: {
+					...lc,
+					lessonIds: rest
+				} });
+				else await area.remove(LAST_CAPTURE_KEY);
+				return { removedCards };
+			});
+		}
+	};
+}
+//#endregion
+//#region src/background/router.ts
+var SETTINGS_KEY = "langcoach:settings";
+/** Pending one-time rollover banners (Banner[]), removed when dismissed. */
+var BANNERS_KEY = "langcoach:banners";
+/** Local date (YYYY-MM-DD) of the last rollover, so the panel triggers it at most once per day. */
+var ROLLOVER_KEY = "langcoach:rolloverDate";
+function toErrorInfo(e) {
+	if (e instanceof CorruptDataError) return {
+		name: e.name,
+		message: e.message,
+		preservedAt: e.preservedAt
+	};
+	if (e instanceof InvalidDataError) return {
+		name: e.name,
+		message: e.message,
+		code: "invalid"
+	};
+	if (e instanceof Error) return {
+		name: e.name,
+		message: e.message
+	};
+	return {
+		name: "Error",
+		message: String(e)
+	};
+}
+var MAX_NATIVE_ENTRIES = 500;
+var MAX_PRACTICE_CARDS = 500;
+var DEFAULT_PRACTICE_CARDS = 200;
+var MAX_PRACTICE_RESULTS = 50;
+var PRACTICE_OUTCOMES = [
+	"correct",
+	"hard",
+	"wrong"
+];
+var MAX_NATIVE_CHARS = 500;
+var CAPTURE_KINDS = [
+	"terms",
+	"grammar",
+	"conversation",
+	"object-descriptors"
+];
+var MAX_JSON = 20971520;
+var bad = (m) => {
+	throw new InvalidDataError(m);
+};
+var isObj$1 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var id = (v, name) => {
+	if (typeof v !== "string" || v === "" || v.length > 200) bad(`${name} must be a non-empty string up to 200 characters`);
+};
+var optStr = (v, name) => {
+	if (v !== void 0 && typeof v !== "string") bad(`${name} must be a string`);
+};
+/** Runtime payload guard per message type; throws InvalidDataError (code 'invalid'). */
+function validateMessage(m) {
+	switch (m.type) {
+		case "capture":
+			if (!CAPTURE_KINDS.includes(m.kind)) bad("kind is not a known capture kind");
+			if (typeof m.pageUrl !== "string") bad("pageUrl must be a string");
+			if (m.force !== void 0 && typeof m.force !== "boolean") bad("force must be a boolean");
+			break;
+		case "undo":
+			if (!Array.isArray(m.lessonIds) || m.lessonIds.length < 1 || m.lessonIds.length > 100) bad("lessonIds must be an array of 1 to 100 ids");
+			m.lessonIds.forEach((x, i) => id(x, `lessonIds[${i}]`));
+			break;
+		case "setProfile":
+			if (!isObj$1(m.profile)) bad("profile must be an object");
+			if (m.theme !== void 0) id(m.theme, "theme");
+			break;
+		case "dismissBanner":
+			id(m.id, "id");
+			break;
+		case "setFavorite":
+			id(m.cardId, "cardId");
+			if (typeof m.favorite !== "boolean") bad("favorite must be a boolean");
+			break;
+		case "markMastered":
+			id(m.cardId, "cardId");
+			break;
+		case "createPlan":
+			id(m.theme, "theme");
+			break;
+		case "completeReview":
+			if (!Number.isInteger(m.cardsReviewed) || m.cardsReviewed < 1 || m.cardsReviewed > 1e3) bad("cardsReviewed must be an integer from 1 to 1000");
+			break;
+		case "getDue":
+			if (!Number.isInteger(m.limit) || m.limit < 1 || m.limit > 200) bad("limit must be an integer from 1 to 200");
+			break;
+		case "review":
+			id(m.cardId, "cardId");
+			if (![
+				1,
+				2,
+				3,
+				4
+			].includes(m.rating)) bad("rating must be 1, 2, 3 or 4");
+			break;
+		case "updateCard":
+			id(m.cardId, "cardId");
+			if (!isObj$1(m.patch)) bad("patch must be an object");
+			optStr(m.patch.translation, "translation");
+			optStr(m.patch.example, "example");
+			break;
+		case "saveManual":
+			id(m.term, "term");
+			optStr(m.translation, "translation");
+			optStr(m.example, "example");
+			optStr(m.pronunciation, "pronunciation");
+			break;
+		case "importData":
+			if (typeof m.json !== "string") bad("json must be a string");
+			else if (m.json.length > MAX_JSON) bad("json is too large (20 MB maximum)");
+			break;
+		case "setSettings":
+			if (!isObj$1(m.settings)) bad("settings must be an object");
+			break;
+		case "getPracticeCards":
+			if (m.limit !== void 0 && (!Number.isInteger(m.limit) || m.limit < 1 || m.limit > MAX_PRACTICE_CARDS)) bad(`limit must be an integer from 1 to ${MAX_PRACTICE_CARDS}`);
+			break;
+		case "recordPractice":
+			if (typeof m.sessionId !== "string" || m.sessionId.trim() === "" || m.sessionId.length > 100) bad("sessionId must be a non-empty string of at most 100 characters");
+			if (!Array.isArray(m.results) || m.results.length < 1 || m.results.length > MAX_PRACTICE_RESULTS) bad(`results must be an array of 1 to ${MAX_PRACTICE_RESULTS} items`);
+			m.results.forEach((r, i) => {
+				if (!isObj$1(r)) bad(`results[${i}] must be an object`);
+				id(r.cardId, `results[${i}].cardId`);
+				if (!PRACTICE_OUTCOMES.includes(r.outcome)) bad(`results[${i}].outcome must be one of ${PRACTICE_OUTCOMES.join(", ")}`);
+			});
+			if (m.matchGames !== void 0 && (!Number.isInteger(m.matchGames) || m.matchGames < 0 || m.matchGames > MAX_PRACTICE_RESULTS)) bad(`matchGames must be an integer from 0 to ${MAX_PRACTICE_RESULTS}`);
+			break;
+		case "setNativeTranslations":
+			if (!Array.isArray(m.entries) || m.entries.length > MAX_NATIVE_ENTRIES) bad(`entries must be an array of at most ${MAX_NATIVE_ENTRIES} items`);
+			m.entries.forEach((e, i) => {
+				if (!isObj$1(e)) bad(`entries[${i}] must be an object`);
+				id(e.cardId, `entries[${i}].cardId`);
+				const text = e.text;
+				const len = typeof text === "string" ? text.trim().length : 0;
+				if (len < 1 || len > MAX_NATIVE_CHARS) bad(`entries[${i}].text must be 1 to ${MAX_NATIVE_CHARS} characters`);
+			});
+	}
+}
+var TIME_RE$1 = /^([01]\d|2[0-3]):[0-5]\d$/;
+var PAIR_RE = /^[a-z]{2,3}(?:-[A-Za-z]{2,4})?:[a-z]{2,3}(?:-[A-Za-z]{2,4})?$/;
+var MAX_DISMISSED_PAIRS = 20;
+var isPairList = (v) => Array.isArray(v) && v.length <= MAX_DISMISSED_PAIRS && v.every((x) => typeof x === "string" && PAIR_RE.test(x));
+function mergeSettings(current, patch) {
+	const next = { ...current };
+	if (patch.autoSave !== void 0) {
+		if (typeof patch.autoSave !== "boolean") throw new InvalidDataError("autoSave must be a boolean");
+		next.autoSave = patch.autoSave;
+	}
+	if (patch.reminderTime !== void 0) {
+		if (patch.reminderTime !== null && !(typeof patch.reminderTime === "string" && TIME_RE$1.test(patch.reminderTime))) throw new InvalidDataError("reminderTime must be \"HH:MM\" or null");
+		next.reminderTime = patch.reminderTime;
+	}
+	if (patch.uiLanguage !== void 0) {
+		if (typeof patch.uiLanguage !== "string" || patch.uiLanguage === "") throw new InvalidDataError("uiLanguage must be a non-empty string");
+		next.uiLanguage = patch.uiLanguage;
+	}
+	if (patch.hasCamera !== void 0) {
+		if (typeof patch.hasCamera !== "boolean") throw new InvalidDataError("hasCamera must be a boolean");
+		next.hasCamera = patch.hasCamera;
+	}
+	if (patch.showNativeOnPage !== void 0) {
+		if (typeof patch.showNativeOnPage !== "boolean") throw new InvalidDataError("showNativeOnPage must be a boolean");
+		next.showNativeOnPage = patch.showNativeOnPage;
+	}
+	if (patch.dismissedNativePairs !== void 0) {
+		if (!isPairList(patch.dismissedNativePairs)) throw new InvalidDataError(`dismissedNativePairs must be up to ${MAX_DISMISSED_PAIRS} pair keys like "en:tr"`);
+		next.dismissedNativePairs = [...new Set(patch.dismissedNativePairs)];
+	}
+	if (patch.soundEffects !== void 0) {
+		if (typeof patch.soundEffects !== "boolean") throw new InvalidDataError("soundEffects must be a boolean");
+		next.soundEffects = patch.soundEffects;
+	}
+	if (patch.bridgeEnabled !== void 0) {
+		if (typeof patch.bridgeEnabled !== "boolean") throw new InvalidDataError("bridgeEnabled must be a boolean");
+		next.bridgeEnabled = patch.bridgeEnabled;
+	}
+	return next;
+}
+function createRouter(deps) {
+	const { coach, store, area } = deps;
+	const clock = deps.clock ?? (() => /* @__PURE__ */ new Date());
+	let settingsTail = Promise.resolve();
+	const serialized = (task) => {
+		const next = settingsTail.then(task, task);
+		settingsTail = next.catch(() => void 0);
+		return next;
+	};
+	async function readSettings() {
+		const raw = (await area.get(SETTINGS_KEY))[SETTINGS_KEY];
+		const st = isObj$1(raw) ? raw : {};
+		return {
+			autoSave: typeof st.autoSave === "boolean" ? st.autoSave : DEFAULT_SETTINGS.autoSave,
+			reminderTime: st.reminderTime === null || typeof st.reminderTime === "string" && TIME_RE$1.test(st.reminderTime) ? st.reminderTime : DEFAULT_SETTINGS.reminderTime,
+			uiLanguage: typeof st.uiLanguage === "string" && st.uiLanguage !== "" ? st.uiLanguage : DEFAULT_SETTINGS.uiLanguage,
+			hasCamera: typeof st.hasCamera === "boolean" ? st.hasCamera : DEFAULT_SETTINGS.hasCamera,
+			showNativeOnPage: typeof st.showNativeOnPage === "boolean" ? st.showNativeOnPage : DEFAULT_SETTINGS.showNativeOnPage,
+			soundEffects: typeof st.soundEffects === "boolean" ? st.soundEffects : DEFAULT_SETTINGS.soundEffects,
+			bridgeEnabled: typeof st.bridgeEnabled === "boolean" ? st.bridgeEnabled : DEFAULT_SETTINGS.bridgeEnabled,
+			...isPairList(st.dismissedNativePairs) && st.dismissedNativePairs.length ? { dismissedNativePairs: st.dismissedNativePairs } : {},
+			...typeof st.pendingTargetLanguage === "string" && st.pendingTargetLanguage !== "" ? { pendingTargetLanguage: st.pendingTargetLanguage } : {}
+		};
+	}
+	const log = deps.log ?? ((...a) => console.warn(...a));
+	const captures = createCaptureService({
+		coach,
+		store,
+		area,
+		clock,
+		log,
+		getAutoSave: async () => (await readSettings()).autoSave,
+		getShowNativeOnPage: async () => (await readSettings()).showNativeOnPage,
+		notePendingTarget: (targetLanguage) => serialized(async () => {
+			const cur = await readSettings();
+			if (cur.pendingTargetLanguage) return;
+			await area.set({ [SETTINGS_KEY]: {
+				...cur,
+				pendingTargetLanguage: targetLanguage
+			} });
+		})
+	});
+	const browserUiLanguage = deps.uiLanguage ?? (() => typeof chrome !== "undefined" && chrome.i18n?.getUILanguage?.() || "en");
+	/**
+	* Creates the current ISO week's plan when a profile exists and the week has none (a new week started).
+	* Returns the state as it is afterwards, so callers need not load it again.
+	*/
+	async function ensurePlan() {
+		const state = await store.load();
+		const week = isoWeek(clock());
+		if (!state.profile || state.plans[week]) return state;
+		const settings = await readSettings();
+		const uiLang = settings.uiLanguage === "auto" ? browserUiLanguage() : settings.uiLanguage;
+		const seed = Number(week.split("-W")[1]) || 0;
+		const theme = suggestThemes(state.profile.goal, state.profile.level, uiLang, seed)[0] ?? "everyday conversation";
+		try {
+			await coach.weekPlan(theme);
+		} catch (e) {
+			log("LangCoach: could not create the weekly plan", e);
+			return state;
+		}
+		return store.load();
+	}
+	const isBanner = (b) => isObj$1(b) && typeof b.id === "string" && (b.kind === "freezeUsed" && typeof b.date === "string" || b.kind === "freezeEarned" && typeof b.count === "number");
+	async function readBanners() {
+		const raw = (await area.get(BANNERS_KEY))[BANNERS_KEY];
+		return Array.isArray(raw) ? raw.filter(isBanner) : [];
+	}
+	/**
+	* Applies streak freezes for today (Coach.rollover) and queues one-time banners for what changed.
+	* Idempotent per day; never throws (startup/alarm callers must not crash the worker).
+	*/
+	async function rollover() {
+		try {
+			const today = toLocalDate(clock());
+			const r = await coach.rollover();
+			const added = [...r.consumed.map((date) => ({
+				id: `freezeUsed:${date}`,
+				kind: "freezeUsed",
+				date
+			})), ...r.earned > 0 ? [{
+				id: `freezeEarned:${today}`,
+				kind: "freezeEarned",
+				count: r.earned
+			}] : []];
+			await serialized(async () => {
+				const items = { [ROLLOVER_KEY]: today };
+				if (added.length > 0) {
+					const cur = await readBanners();
+					const ids = new Set(cur.map((b) => b.id));
+					items[BANNERS_KEY] = [...cur, ...added.filter((b) => !ids.has(b.id))].slice(-10);
+				}
+				await area.set(items);
+			});
+			return added;
+		} catch (e) {
+			log("LangCoach: daily rollover failed", e);
+			return [];
+		}
+	}
+	async function snapshot() {
+		const now0 = clock();
+		if ((await area.get("langcoach:rolloverDate"))["langcoach:rolloverDate"] !== toLocalDate(now0)) await rollover();
+		const [state, lc, banners] = await Promise.all([
+			ensurePlan(),
+			area.get(LAST_CAPTURE_KEY),
+			readBanners()
+		]);
+		const now = clock();
+		const date = toLocalDate(now);
+		const plan = state.plans[isoWeek(now)] ?? null;
+		const p = progressOf(state, now);
+		return {
+			profile: state.profile,
+			today: state.profile ? {
+				date,
+				tasks: plan ? plan.tasks.filter((t) => t.date === date) : [],
+				planExists: plan !== null
+			} : null,
+			plan,
+			progress: {
+				streak: p.streak,
+				totalXp: p.totalXp,
+				weekly: p.weekly,
+				dueCount: p.dueCount,
+				todayXp: p.todayXp,
+				dailyGoalXp: p.dailyGoalXp,
+				streakFreezes: p.streakFreezes,
+				weekXp: p.weekXp
+			},
+			dueCount: p.dueCount,
+			lastCapture: lc["langcoach:lastCapture"] ?? null,
+			banners,
+			state
+		};
+	}
+	const handlers = {
+		capture: async (m, ctx) => {
+			const r = await captures.capture({
+				kind: m.kind,
+				request: m.request,
+				response: m.response,
+				pageUrl: m.pageUrl,
+				force: m.force
+			}, ctx);
+			if (r?.status !== "saved" || !deps.bridge) return r;
+			try {
+				const { sent } = await deps.bridge.flush();
+				if (r.lessonIds.every((id) => sent.includes(id))) return {
+					...r,
+					forwarded: true
+				};
+			} catch (e) {
+				log("LangCoach: forwarding to the agent failed", e);
+			}
+			return r;
+		},
+		undo: (m) => captures.undo(m.lessonIds),
+		openPanel: async (_m, ctx) => {
+			if (ctx.tabId === void 0) throw new InvalidDataError("openPanel must come from a tab");
+			await (deps.sidePanel ?? chrome.sidePanel).open({ tabId: ctx.tabId });
+			return null;
+		},
+		getSnapshot: () => snapshot(),
+		setProfile: (m) => coach.setProfile(m.profile, m.theme !== void 0 ? { theme: m.theme } : {}),
+		createPlan: (m) => coach.weekPlan(m.theme),
+		completeReview: (m) => coach.autoComplete("review", { cardsReviewed: m.cardsReviewed }),
+		getDue: (m) => coach.dueReviews(m.limit),
+		review: (m) => coach.submitReview(m.cardId, m.rating),
+		updateCard: (m) => coach.updateCard(m.cardId, m.patch),
+		saveManual: (m) => coach.saveManualCard({
+			term: m.term,
+			translation: m.translation,
+			example: m.example,
+			pronunciation: m.pronunciation
+		}),
+		exportData: async () => ({ json: JSON.stringify(await coach.exportData(), null, 2) }),
+		importData: async (m) => {
+			let raw;
+			try {
+				raw = JSON.parse(m.json);
+			} catch {
+				throw new InvalidDataError("The file is not valid JSON");
+			}
+			return coach.importData(raw);
+		},
+		reset: async () => {
+			await coach.deleteAll();
+			await area.remove(LAST_CAPTURE_KEY);
+			return null;
+		},
+		getSettings: () => readSettings(),
+		setSettings: (m) => serialized(async () => {
+			const next = mergeSettings(await readSettings(), m.settings);
+			await area.set({ [SETTINGS_KEY]: next });
+			if (deps.onSettingsChanged) await deps.onSettingsChanged(next);
+			return next;
+		}),
+		setNativeTranslations: (m) => coach.setNativeTranslations(m.entries),
+		getPracticeCards: async (m) => {
+			const state = await store.load();
+			const now = clock();
+			const rank = (c) => isDue(c.srs, now) ? c.srs.reps > 0 ? 0 : 1 : 2;
+			return state.cards.map((c, i) => ({
+				c,
+				i,
+				r: rank(c)
+			})).sort((a, b) => a.r - b.r || (a.r === 0 ? Date.parse(a.c.srs.due) - Date.parse(b.c.srs.due) : 0) || a.i - b.i).slice(0, m.limit ?? DEFAULT_PRACTICE_CARDS).map((x) => x.c);
+		},
+		recordPractice: (m) => coach.recordPractice({
+			sessionId: m.sessionId,
+			results: m.results,
+			...m.matchGames !== void 0 ? { matchGames: m.matchGames } : {}
+		}),
+		setFavorite: (m) => coach.setFavorite(m.cardId, m.favorite),
+		markMastered: (m) => coach.markMastered(m.cardId),
+		bridgeStatus: async () => deps.bridge ? deps.bridge.status() : {
+			state: "off",
+			pending: 0,
+			lastSentAt: null
+		},
+		dismissBanner: (m) => serialized(async () => {
+			const cur = await readBanners();
+			await area.set({ [BANNERS_KEY]: cur.filter((b) => b.id !== m.id) });
+			return null;
+		})
+	};
+	return {
+		/** Applies streak freezes for today and queues one-time banners. Never throws. */
+		rollover,
+		/** Creates this week's plan if a profile exists and the week has none (startup, alarms). Never throws. */
+		async ensurePlan() {
+			try {
+				await ensurePlan();
+			} catch (e) {
+				log("LangCoach: weekly plan check failed", e);
+			}
+		},
+		/** `ctx.tabId` is the sender tab (content-script messages). */
+		async handle(msg, ctx = {}) {
+			try {
+				validateMessage(msg);
+				const h = handlers[msg.type];
+				return {
+					ok: true,
+					data: await h(msg, ctx)
+				};
+			} catch (e) {
+				return {
+					ok: false,
+					error: toErrorInfo(e)
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/background/bridge.ts
+/**
+* The local langcoach MCP server (loopback only, token-paired; protocol in packages/mcp/src/bridge.ts).
+* The e2e build talks to a stub on another port, so tests never reach a real agent's data on this machine.
+*/
+var BRIDGE_ORIGIN = "http://127.0.0.1:47821";
+var BRIDGE_ALARM = "langcoach-bridge";
+/** Packaged by the agent's bridge_prepare_extension; never part of the store build. */
+var PAIRING_FILE = "pairing.json";
+/** chrome.storage.session cache of the pairing token (cleared when the browser closes; never synced). */
+var PAIRING_SESSION_KEY = "langcoach:pairing";
+/** Lesson ids the agent confirmed (saved or duplicate), oldest first. */
+var SENT_KEY = "langcoach:bridgeSent";
+/** Rejections per lesson id; a lesson rejected MAX_REJECTS times is not sent again. */
+var ERRORS_KEY = "langcoach:bridgeErrors";
+/** { state, lastSentAt, retryAt, failures } */
+var BRIDGE_STATE_KEY = "langcoach:bridgeState";
+/** After a 401 the token is re-tried at most this often. */
+var UNPAIRED_RETRY_MS = 6e5;
+/** Unverified server: back off 2, 4, 8, 16, then 30 minutes. */
+var MAX_BACKOFF_MS = 18e5;
+var BATCH = 10;
+var TOKEN_RE = /^[0-9a-f]{32,256}$/i;
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var hex = (b) => Array.from(b instanceof Uint8Array ? b : new Uint8Array(b), (x) => x.toString(16).padStart(2, "0")).join("");
+var STATES = [
+	"connected",
+	"waiting",
+	"unpaired",
+	"unverified",
+	"off"
+];
+/** Constant-time string comparison (length is not secret: both are SHA-256 hex). */
+function ctEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let d = 0;
+	for (let i = 0; i < a.length; i++) d |= a.charCodeAt(i) ^ b.charCodeAt(i);
+	return d === 0;
+}
+/** Lowercase hex HMAC-SHA256 with the UTF-8 bytes of `token` as key and of `nonce` as message. */
+async function hmacHex(token, nonce) {
+	const enc = new TextEncoder();
+	const key = await crypto.subtle.importKey("raw", enc.encode(token), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return hex(await crypto.subtle.sign("HMAC", key, enc.encode(nonce)));
+}
+/** The token of a valid pairing file ({"token":"<hex>","port":47821,"v":1}), else null. */
+function parsePairing(v) {
+	if (!isObj(v) || v.v !== 1 || typeof v.token !== "string" || !TOKEN_RE.test(v.token)) return null;
+	if (v.port !== Number(new URL("http://127.0.0.1:47821").port)) return null;
+	return v.token;
+}
+/** Server field caps: it rejects (never truncates) a lesson over them, so the client never sends one. */
+var CAPS = {
+	term: 200,
+	translation: 500,
+	example: 500,
+	note: 500,
+	pronunciation: 200
+};
+var within = (v, max) => v === void 0 || typeof v === "string" && v.length <= max;
+var itemFits = (i) => Object.keys(CAPS).every((k) => within(i[k], CAPS[k]));
+/** The lesson as sent: items over the caps are skipped; null when nothing sendable is left. */
+function payload(l) {
+	const items = l.items.filter(itemFits);
+	const src = l.source;
+	if (!items.length || l.situation.length > 200) return null;
+	if (src && (!within(src.purpose, 100) || src.targetLanguage.length > 80 || src.sourceLanguage.length > 80)) return null;
+	return {
+		id: l.id,
+		kind: l.kind,
+		situation: l.situation,
+		items: items.map((i) => ({
+			term: i.term,
+			translation: i.translation,
+			example: i.example,
+			...i.note !== void 0 ? { note: i.note } : {},
+			...i.pronunciation !== void 0 ? { pronunciation: i.pronunciation } : {}
+		})),
+		...l.grammar ? { grammar: l.grammar } : {},
+		...l.source ? { source: l.source } : {},
+		capturedAt: l.createdAt
+	};
+}
+var defaultReadPairing = async () => {
+	const res = await fetch(chrome.runtime.getURL(PAIRING_FILE));
+	return res.ok ? res.json() : null;
+};
+/** Bridge client. Never throws: every failure is logged (never the token) and leaves the lesson in the backlog. */
+function createBridge(deps) {
+	const { store, area, alarms } = deps;
+	const doFetch = deps.fetch ?? ((...a) => fetch(...a));
+	const log = deps.log ?? ((...a) => console.warn(...a));
+	const clock = deps.clock ?? (() => /* @__PURE__ */ new Date());
+	const timeoutMs = deps.timeoutMs ?? 4e3;
+	let token;
+	let tail = Promise.resolve();
+	const serialized = (task) => {
+		const next = tail.then(task, task);
+		tail = next.catch(() => void 0);
+		return next;
+	};
+	/** Memory, then the session cache, then the packaged file. */
+	async function getToken() {
+		if (token !== void 0) return token;
+		try {
+			const cached = deps.session ? (await deps.session.get(PAIRING_SESSION_KEY))[PAIRING_SESSION_KEY] : void 0;
+			if (typeof cached === "string" && TOKEN_RE.test(cached)) return token = cached;
+		} catch {}
+		try {
+			token = parsePairing(await (deps.readPairing ?? defaultReadPairing)());
+		} catch {
+			token = null;
+		}
+		if (token && deps.session) await deps.session.set({ [PAIRING_SESSION_KEY]: token }).catch(() => void 0);
+		return token;
+	}
+	/** Status code and JSON body, or null on network failure / timeout / bad JSON. */
+	async function request(path, init) {
+		const ctrl = new AbortController();
+		const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+		try {
+			const res = await doFetch(`${BRIDGE_ORIGIN}${path}`, {
+				...init,
+				signal: ctrl.signal
+			});
+			let body = null;
+			try {
+				body = await res.json();
+			} catch {}
+			return {
+				status: res.status,
+				body: isObj(body) ? body : null
+			};
+		} catch {
+			return null;
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async function enabled() {
+		const st = (await area.get(SETTINGS_KEY))[SETTINGS_KEY];
+		return !(isObj(st) && st.bridgeEnabled === false);
+	}
+	async function readState() {
+		const got = await area.get([
+			SENT_KEY,
+			ERRORS_KEY,
+			BRIDGE_STATE_KEY
+		]);
+		const sent = Array.isArray(got["langcoach:bridgeSent"]) ? got[SENT_KEY].filter((x) => typeof x === "string") : [];
+		const errors = {};
+		if (isObj(got["langcoach:bridgeErrors"])) {
+			for (const [k, v] of Object.entries(got[ERRORS_KEY])) if (typeof v === "number") errors[k] = v;
+		}
+		const b = isObj(got["langcoach:bridgeState"]) ? got[BRIDGE_STATE_KEY] : {};
+		return {
+			sent,
+			errors,
+			p: {
+				state: STATES.includes(b.state) ? b.state : null,
+				lastSentAt: typeof b.lastSentAt === "string" ? b.lastSentAt : null,
+				retryAt: typeof b.retryAt === "number" ? b.retryAt : 0,
+				failures: typeof b.failures === "number" ? b.failures : 0
+			}
+		};
+	}
+	/** LLL lessons not confirmed yet and not given up on, newest BACKLOG_LIMIT in time order. */
+	async function backlog(sent, errors) {
+		const done = new Set(sent);
+		return (await store.load()).lessons.filter((l) => l.source?.app === "lll" && !done.has(l.id) && (errors[l.id] ?? 0) < 3 && payload(l) !== null).slice(-200);
+	}
+	/**
+	* Authenticates the server before anything is sent: it must answer a fresh nonce with
+	* HMAC-SHA256(token, nonce). 'waiting' = nobody answered; 'unverified' = something answered without proof.
+	*/
+	async function ping() {
+		const tk = await getToken();
+		if (!tk) return "unpaired";
+		const nonce = hex(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)));
+		const r = await request(`/v1/ping?nonce=${nonce}`, {
+			method: "GET",
+			headers: { "X-LangCoach": "1" }
+		});
+		if (!r) return "waiting";
+		const b = r.body;
+		if (r.status !== 200 || !b || b.ok !== true || b.app !== "langcoach" || typeof b.proof !== "string") return "unverified";
+		return ctEqual(b.proof.toLowerCase(), await hmacHex(tk, nonce)) ? "connected" : "unverified";
+	}
+	/**
+	* Posts in batches of BATCH to an already verified server; stops at the first failed batch.
+	* `results` is null when nothing reached the agent; `unauthorized` on a 401 (token not accepted).
+	*/
+	async function sendLessons(lessons) {
+		const tk = await getToken();
+		if (!tk) return {
+			results: null,
+			unauthorized: true
+		};
+		const out = [];
+		for (let i = 0; i < lessons.length; i += BATCH) {
+			const r = await request("/v1/lessons", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-LangCoach": "1",
+					"X-LangCoach-Token": tk
+				},
+				body: JSON.stringify({
+					client: {
+						name: "langcoach-extension",
+						version
+					},
+					lessons: lessons.slice(i, i + BATCH).flatMap((l) => payload(l) ?? [])
+				})
+			});
+			if (r?.status === 401) return {
+				results: out.length ? out : null,
+				unauthorized: true
+			};
+			if (!r || r.status !== 200 || !r.body || r.body.ok !== true || !Array.isArray(r.body.results)) return {
+				results: out.length ? out : null,
+				unauthorized: false
+			};
+			for (const x of r.body.results) if (isObj(x) && typeof x.id === "string" && [
+				"saved",
+				"duplicate",
+				"rejected"
+			].includes(x.status)) out.push(x);
+		}
+		return {
+			results: out,
+			unauthorized: false
+		};
+	}
+	async function syncAlarm(on) {
+		if (!on) await alarms.clear(BRIDGE_ALARM);
+		else if (!await alarms.get("langcoach-bridge")) await alarms.create(BRIDGE_ALARM, { periodInMinutes: 2 });
+	}
+	async function flushOnce() {
+		if (!await enabled()) {
+			await syncAlarm(false);
+			return {
+				sent: [],
+				pending: 0,
+				state: "off"
+			};
+		}
+		const { sent, errors, p } = await readState();
+		const todo = await backlog(sent, errors);
+		if (!await getToken()) {
+			await syncAlarm(false);
+			await area.set({ [BRIDGE_STATE_KEY]: {
+				...p,
+				state: "unpaired"
+			} });
+			return {
+				sent: [],
+				pending: todo.length,
+				state: "unpaired"
+			};
+		}
+		const now = clock().getTime();
+		if (p.retryAt > now && p.state) {
+			await syncAlarm(true);
+			return {
+				sent: [],
+				pending: todo.length,
+				state: p.state
+			};
+		}
+		let state = await ping();
+		const confirmed = [];
+		const next = {
+			...p,
+			retryAt: 0,
+			failures: 0
+		};
+		if (state === "connected" && todo.length) {
+			const { results, unauthorized } = await sendLessons(todo);
+			if (unauthorized) state = "unpaired";
+			else if (results === null) state = "waiting";
+			const known = new Set(todo.map((l) => l.id));
+			for (const r of results ?? []) {
+				if (!known.has(r.id)) continue;
+				if (r.status === "rejected") {
+					errors[r.id] = (errors[r.id] ?? 0) + 1;
+					log(`LangCoach: the agent rejected lesson ${r.id}: ${r.error ?? "no reason given"}`);
+				} else {
+					confirmed.push(r.id);
+					delete errors[r.id];
+				}
+			}
+		}
+		if (state === "unpaired") {
+			next.retryAt = now + UNPAIRED_RETRY_MS;
+			log("LangCoach: the agent did not accept this extension's pairing; reinstall it from your agent");
+		} else if (state === "unverified") {
+			next.failures = p.failures + 1;
+			next.retryAt = now + Math.min(12e4 * 2 ** (next.failures - 1), MAX_BACKOFF_MS);
+			log("LangCoach: something on the bridge port did not prove it is your LangCoach agent; nothing was sent");
+		}
+		next.state = state;
+		if (confirmed.length) next.lastSentAt = clock().toISOString();
+		const items = { [BRIDGE_STATE_KEY]: next };
+		if (confirmed.length) items[SENT_KEY] = [.../* @__PURE__ */ new Set([...sent, ...confirmed])].slice(-1e3);
+		if (todo.length) items[ERRORS_KEY] = Object.fromEntries(Object.entries(errors).filter(([id]) => todo.some((l) => l.id === id)));
+		await area.set(items);
+		const pending = todo.filter((l) => !confirmed.includes(l.id) && (errors[l.id] ?? 0) < 3).length;
+		await syncAlarm(pending > 0 || state !== "connected");
+		return {
+			sent: confirmed,
+			pending,
+			state
+		};
+	}
+	async function flush() {
+		return serialized(async () => {
+			try {
+				return await flushOnce();
+			} catch (e) {
+				log("LangCoach: agent bridge flush failed", e);
+				return {
+					sent: [],
+					pending: 0,
+					state: "waiting"
+				};
+			}
+		});
+	}
+	async function status() {
+		try {
+			const { sent, errors, p } = await readState();
+			if (!await enabled()) return {
+				state: "off",
+				pending: 0,
+				lastSentAt: p.lastSentAt
+			};
+			const pending = (await backlog(sent, errors)).length;
+			return {
+				state: p.state === "unpaired" && p.retryAt > clock().getTime() ? "unpaired" : await ping(),
+				pending,
+				lastSentAt: p.lastSentAt
+			};
+		} catch (e) {
+			log("LangCoach: agent bridge status failed", e);
+			return {
+				state: "waiting",
+				pending: 0,
+				lastSentAt: null
+			};
+		}
+	}
+	return {
+		ping,
+		sendLessons,
+		flush,
+		status,
+		/** chrome.alarms listener: flushes on the bridge alarm only. */
+		async onAlarm(alarm) {
+			if (alarm.name === "langcoach-bridge") await flush();
+		}
+	};
+}
+//#endregion
+//#region src/background/menu.ts
+var MENU_ID = "langcoach-save-selection";
+var LLL_PATTERNS = ["https://labs.google/lll/*"];
+var DEV_PATTERNS = DEV_HOSTNAMES.map((h) => `http://${h}/*`);
+/** Idempotent: safe on every install/startup. */
+async function registerMenus(menus, t, e2e) {
+	await menus.removeAll();
+	menus.create({
+		id: MENU_ID,
+		title: t("menuSave"),
+		contexts: ["selection"],
+		documentUrlPatterns: e2e ? [...LLL_PATTERNS, ...DEV_PATTERNS] : LLL_PATTERNS
+	});
+}
+/** "Save to LangCoach" on selected text: a card with the selection as its term, then a toast in the tab. */
+function createMenuClickHandler(deps) {
+	return async (info, tab) => {
+		if (info.menuItemId !== "langcoach-save-selection") return;
+		const term = (info.selectionText ?? "").trim().slice(0, 200);
+		if (!term) return;
+		try {
+			const r = await deps.coach.saveManualCard({ term });
+			if (tab?.id === void 0 || tab.id < 0) return;
+			await deps.tabs.sendMessage(tab.id, {
+				type: "toast",
+				variant: r.duplicate ? "already" : "manual"
+			});
+		} catch (e) {
+			deps.log("LangCoach: manual save failed", e);
+		}
+	};
+}
+//#endregion
+//#region src/background/policy.ts
+/** Messages content scripts on the lesson site may send. */
+var CONTENT_TYPES = /* @__PURE__ */ new Set([
+	"capture",
+	"undo",
+	"saveManual",
+	"openPanel",
+	"setNativeTranslations"
+]);
+/** Messages extension pages (side panel) may send. */
+var PAGE_TYPES = /* @__PURE__ */ new Set([
+	"getSnapshot",
+	"setProfile",
+	"createPlan",
+	"completeReview",
+	"getDue",
+	"review",
+	"updateCard",
+	"undo",
+	"saveManual",
+	"exportData",
+	"importData",
+	"reset",
+	"getSettings",
+	"setSettings",
+	"setNativeTranslations",
+	"getPracticeCards",
+	"recordPractice",
+	"dismissBanner",
+	"setFavorite",
+	"markMastered",
+	"bridgeStatus"
+]);
+var LLL_PREFIX = "https://labs.google/lll/";
+/** Pure sender policy for runtime messages. */
+function isAllowed(type, sender, runtimeId, extensionOrigin, e2e) {
+	if (!sender || sender.id !== runtimeId) return false;
+	const url = typeof sender.url === "string" ? sender.url : "";
+	if (PAGE_TYPES.has(type) && url !== "" && url.startsWith(extensionOrigin)) return true;
+	if (CONTENT_TYPES.has(type)) {
+		if (!sender.tab) return false;
+		return url.startsWith(LLL_PREFIX) || e2e && isDevHostUrl(url);
+	}
+	return false;
+}
+//#endregion
+//#region src/background/reminder.ts
+var REMINDER_ALARM = "langcoach-reminder";
+var REMINDER_NOTIFICATION_ID = "langcoach-daily-reminder";
+/** Daily alarm that applies streak freezes shortly after local midnight. */
+var ROLLOVER_ALARM = "langcoach-rollover";
+var ROLLOVER_TIME = "00:01";
+var LLL_HOME = "https://labs.google/lll/en";
+var LLL_TABS = "https://labs.google/lll/*";
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
+/**
+* Computes the next occurrence (epoch ms) of `time` ("HH:MM") in local time:
+* today if strictly ahead of `now`, otherwise tomorrow at the same local wall-clock time (DST-safe).
+*/
+function nextReminderAt(now, time) {
+	const m = TIME_RE.exec(time);
+	if (!m) throw new Error(`Invalid reminder time: ${time}`);
+	const hours = Number(m[1]);
+	const minutes = Number(m[2]);
+	const candidate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes, 0, 0);
+	if (candidate.getTime() > now.getTime()) return candidate.getTime();
+	return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, hours, minutes, 0, 0).getTime();
+}
+async function scheduleReminder(settings, alarms = chrome.alarms, now = /* @__PURE__ */ new Date()) {
+	if (!settings.reminderTime || !TIME_RE.test(settings.reminderTime)) {
+		await alarms.clear(REMINDER_ALARM);
+		return;
+	}
+	const when = nextReminderAt(now, settings.reminderTime);
+	await alarms.create(REMINDER_ALARM, { when });
+}
+/** Schedules the next daily rollover (00:01 local, one-shot; re-created when it fires). */
+async function scheduleRollover(alarms = chrome.alarms, now = /* @__PURE__ */ new Date()) {
+	await alarms.create(ROLLOVER_ALARM, { when: nextReminderAt(now, ROLLOVER_TIME) });
+}
+function createRolloverAlarmHandler(deps) {
+	return async (alarm) => {
+		if (alarm.name !== "langcoach-rollover") return;
+		try {
+			await deps.rollover();
+		} catch {}
+		try {
+			await deps.reschedule();
+		} catch {}
+	};
+}
+function createReminderAlarmHandler(deps) {
+	return async (alarm) => {
+		if (alarm.name !== "langcoach-reminder") return;
+		try {
+			await notifyIfNeeded();
+		} finally {
+			if (deps.reschedule) await deps.reschedule().catch(() => void 0);
+		}
+	};
+	async function notifyIfNeeded() {
+		try {
+			if (deps.ensurePlan) await deps.ensurePlan();
+			const state = await deps.coach.exportData();
+			if (!state.profile) return;
+			const today = await deps.coach.today();
+			if (state.log.some((e) => e.date === today.date)) return;
+			if (!today.tasks.some((task) => task.status === "todo")) return;
+			await deps.notifications.create(REMINDER_NOTIFICATION_ID, {
+				type: "basic",
+				iconUrl: deps.iconUrl,
+				title: deps.t("reminderTitle"),
+				message: deps.t("reminderBody")
+			});
+		} catch {}
+	}
+}
+/**
+* Notification click. Chrome only lets `sidePanel.open()` run in response to a user gesture, and a
+* notification click does not always count as one (it throws "may only be called in response to a
+* user gesture"). So: try the side panel in the current window; if Chrome refuses, focus an open LLL
+* tab (the learner opens the panel from the toolbar there), else open LLL in a new tab.
+*/
+function createReminderClickHandler(deps) {
+	return async (notificationId) => {
+		if (notificationId !== "langcoach-daily-reminder") return;
+		try {
+			await deps.notifications.clear(notificationId);
+		} catch {}
+		try {
+			const winId = (await deps.tabs.query({
+				active: true,
+				currentWindow: true
+			}))[0]?.windowId;
+			if (winId !== void 0) {
+				await deps.sidePanel.open({ windowId: winId });
+				return;
+			}
+		} catch {}
+		try {
+			const lll = (await deps.tabs.query({ url: LLL_TABS })).find((t) => t.id !== void 0);
+			if (lll?.id !== void 0 && deps.tabs.update) {
+				await deps.tabs.update(lll.id, { active: true });
+				if (lll.windowId !== void 0 && deps.windows) await deps.windows.update(lll.windowId, { focused: true });
+				return;
+			}
+		} catch {}
+		try {
+			await deps.tabs.create({ url: LLL_HOME });
+		} catch {}
+	};
+}
+//#endregion
+//#region src/background/store.ts
+var STATE_KEY = "langcoach:state";
+var BACKUP_PREFIX = "langcoach:backup:";
+/** Promise-chain mutex: runs tasks one at a time, in call order. */
+var Mutex = class {
+	tail = Promise.resolve();
+	run(task) {
+		const next = this.tail.then(task, task);
+		this.tail = next.catch(() => void 0);
+		return next;
+	}
+};
+var seq = 0;
+/** Sortable, unique-per-process suffix: ISO time then a monotonic counter. */
+var stamp = () => `${(/* @__PURE__ */ new Date()).toISOString()}-${String(++seq % 1e6).padStart(6, "0")}`;
+/** State kept as a JSON string in chrome.storage.local; the background service worker is its only writer. */
+var ChromeStorageStore = class {
+	area;
+	mutex = new Mutex();
+	constructor(area = chrome.storage.local) {
+		this.area = area;
+	}
+	async load() {
+		const raw = (await this.area.get(STATE_KEY))[STATE_KEY];
+		if (raw === void 0) return emptyState();
+		let parsed;
+		try {
+			if (typeof raw !== "string") throw new Error("stored state is not a string");
+			parsed = JSON.parse(raw);
+		} catch {
+			const all = await this.area.get(null);
+			const existing = Object.keys(all).find((k) => k.startsWith("langcoach:corrupt:") && all[k] === raw);
+			const preservedAt = existing ?? `langcoach:corrupt:${stamp()}`;
+			if (!existing) await this.area.set({ [preservedAt]: raw });
+			throw new CorruptDataError(`Stored data is not valid JSON. The original was preserved under ${preservedAt}. Import a backup or reset to start fresh.`, preservedAt);
+		}
+		return parseState(parsed);
+	}
+	async save(s) {
+		parseState(s);
+		await this.area.set({ [STATE_KEY]: JSON.stringify(s) });
+	}
+	async backup() {
+		const raw = (await this.area.get(STATE_KEY))[STATE_KEY];
+		if (raw === void 0) return null;
+		const key = `${BACKUP_PREFIX}${stamp()}`;
+		await this.area.set({ [key]: raw });
+		const all = Object.keys(await this.area.get(null)).filter((k) => k.startsWith(BACKUP_PREFIX)).sort();
+		if (all.length > 3) await this.area.remove(all.slice(0, all.length - 3));
+		return key;
+	}
+	transaction(fn) {
+		return this.mutex.run(async () => {
+			const out = await fn(await this.load());
+			if (out.state !== void 0) await this.save(out.state);
+			return out.result;
+		});
+	}
+	async replace(next) {
+		parseState(next);
+		return this.mutex.run(async () => {
+			const key = await this.backup();
+			await this.save(next);
+			return key;
+		});
+	}
+};
+//#endregion
+//#region src/background/index.ts
+var store = new ChromeStorageStore();
+var coach = new Coach(store);
+var log = (...a) => console.warn(...a);
+var bridge = createBridge({
+	store,
+	area: chrome.storage.local,
+	session: chrome.storage.session,
+	alarms: chrome.alarms,
+	log
+});
+var router = createRouter({
+	coach,
+	store,
+	area: chrome.storage.local,
+	sidePanel: chrome.sidePanel,
+	onSettingsChanged: (settings) => {
+		bridge.flush();
+		return scheduleReminder(settings, chrome.alarms);
+	},
+	log,
+	uiLanguage: () => chrome.i18n.getUILanguage(),
+	bridge
+});
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+	if (!isMessage(msg)) return false;
+	if (!isAllowed(msg.type, sender, chrome.runtime.id, chrome.runtime.getURL(""), false)) {
+		sendResponse({
+			ok: false,
+			error: {
+				name: "Forbidden",
+				message: "Sender not allowed",
+				code: "forbidden"
+			}
+		});
+		return false;
+	}
+	router.handle(msg, { tabId: sender.tab?.id }).then(sendResponse);
+	return true;
+});
+var setupMenus = () => registerMenus(chrome.contextMenus, (k) => chrome.i18n.getMessage(k), false).catch((e) => log("LangCoach: context menu setup failed", e));
+var syncReminder = () => router.handle({ type: "getSettings" }).then((r) => r.ok ? scheduleReminder(r.data, chrome.alarms) : void 0).catch((e) => log("LangCoach: reminder schedule failed", e));
+var syncRollover = () => scheduleRollover(chrome.alarms).catch((e) => log("LangCoach: rollover schedule failed", e));
+chrome.runtime.onInstalled.addListener(() => {
+	chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: true });
+	setupMenus();
+	syncReminder();
+	syncRollover();
+	router.ensurePlan();
+});
+chrome.runtime.onStartup.addListener(() => {
+	setupMenus();
+	syncReminder();
+	syncRollover();
+	router.ensurePlan();
+});
+router.rollover();
+bridge.flush();
+var onMenuClick = createMenuClickHandler({
+	coach,
+	tabs: chrome.tabs,
+	log
+});
+chrome.contextMenus.onClicked.addListener((info, tab) => void onMenuClick(info, tab));
+var onAlarm = createReminderAlarmHandler({
+	coach,
+	notifications: chrome.notifications,
+	t: (k) => chrome.i18n.getMessage(k),
+	iconUrl: chrome.runtime.getURL("icons/128.png"),
+	ensurePlan: () => router.ensurePlan(),
+	reschedule: () => syncReminder().then(() => void 0)
+});
+var onRolloverAlarm = createRolloverAlarmHandler({
+	rollover: () => router.rollover(),
+	reschedule: syncRollover
+});
+chrome.alarms.onAlarm.addListener((alarm) => {
+	onAlarm(alarm);
+	onRolloverAlarm(alarm);
+	bridge.onAlarm(alarm);
+});
+var onNotificationClick = createReminderClickHandler({
+	sidePanel: chrome.sidePanel,
+	tabs: chrome.tabs,
+	windows: chrome.windows,
+	notifications: chrome.notifications
+});
+chrome.notifications.onClicked.addListener((id) => void onNotificationClick(id));
+//#endregion