langcoach 0.1.0 → 0.3.0

package/extension/content-isolated.js

@@ -0,0 +1,934 @@
+(function() {
+	/** At most `max` UTF-16 code units (the core/router limit), never ending on half a surrogate pair. */
+	function capUnits(s, max) {
+		if (s.length <= max) return s;
+		const cut = s.slice(0, max);
+		const last = cut.charCodeAt(cut.length - 1);
+		return last >= 55296 && last <= 56319 ? cut.slice(0, -1) : cut;
+	}
+	var STATES = [
+		"available",
+		"downloadable",
+		"downloading",
+		"unavailable"
+	];
+	[...Object.values({
+		english: "en",
+		ingilizce: "en",
+		"i̇ngilizce": "en",
+		inglés: "en",
+		ingles: "en",
+		anglais: "en",
+		inglês: "en",
+		turkish: "tr",
+		türkçe: "tr",
+		turkce: "tr",
+		turco: "tr",
+		turc: "tr",
+		spanish: "es",
+		español: "es",
+		espanol: "es",
+		espagnol: "es",
+		espanhol: "es",
+		french: "fr",
+		français: "fr",
+		francais: "fr",
+		francés: "fr",
+		francês: "fr",
+		portuguese: "pt",
+		português: "pt",
+		portugues: "pt",
+		portugués: "pt",
+		german: "de",
+		deutsch: "de",
+		arabic: "ar",
+		chinese: "zh",
+		japanese: "ja",
+		korean: "ko",
+		russian: "ru",
+		hindi: "hi",
+		italian: "it",
+		italiano: "it",
+		dutch: "nl",
+		polish: "pl",
+		ukrainian: "uk",
+		vietnamese: "vi",
+		indonesian: "id",
+		greek: "el",
+		hebrew: "he",
+		persian: "fa",
+		urdu: "ur",
+		bengali: "bn",
+		thai: "th"
+	})];
+	var globalApi = () => {
+		const g = globalThis;
+		return "Translator" in globalThis ? g.Translator : void 0;
+	};
+	function createTranslatorCache(api, getGlobal = globalApi) {
+		const getApi = () => api ?? getGlobal();
+		/** Pair key → translator being created / created (a failed create is forgotten so it can be retried). */
+		const translators = /* @__PURE__ */ new Map();
+		const results = /* @__PURE__ */ new Map();
+		const key = (src, dst) => `${src}\u0000${dst}`;
+		async function available(src, dst) {
+			try {
+				const a = getApi();
+				if (!a || typeof a.availability !== "function") return "unavailable";
+				const r = await a.availability({
+					sourceLanguage: src,
+					targetLanguage: dst
+				});
+				return STATES.includes(r) ? r : "unavailable";
+			} catch {
+				return "unavailable";
+			}
+		}
+		/** Starts `create` synchronously (keeps the click's user activation); caches the promise. */
+		function create(src, dst, onProgress) {
+			const k = key(src, dst);
+			const existing = translators.get(k);
+			if (existing) return existing;
+			let p;
+			try {
+				const a = getApi();
+				if (!a || typeof a.create !== "function") return Promise.resolve(null);
+				p = Promise.resolve(a.create({
+					sourceLanguage: src,
+					targetLanguage: dst,
+					monitor(m) {
+						try {
+							m.addEventListener("downloadprogress", (e) => {
+								const loaded = e.loaded;
+								if (typeof loaded === "number" && onProgress) onProgress(loaded);
+							});
+						} catch {}
+					}
+				})).then((t) => t && typeof t.translate === "function" ? t : null, () => null);
+			} catch {
+				p = Promise.resolve(null);
+			}
+			translators.set(k, p);
+			p.then((t) => {
+				if (!t && translators.get(k) === p) translators.delete(k);
+			});
+			return p;
+		}
+		async function ensureReady(src, dst, opts) {
+			if (opts.userGesture) return await create(src, dst, opts.onProgress) ? "available" : "unavailable";
+			const k = key(src, dst);
+			if (translators.has(k)) return await translators.get(k) ? "available" : "unavailable";
+			const a = await available(src, dst);
+			if (a === "downloadable") return "needs_download";
+			if (a !== "available") return a;
+			return await create(src, dst) ? "available" : "unavailable";
+		}
+		async function translateOne(t, text) {
+			try {
+				const out = await t.translate(text);
+				if (typeof out !== "string") return null;
+				const trimmed = out.trim();
+				return trimmed === "" ? null : capUnits(trimmed, 500);
+			} catch {
+				return null;
+			}
+		}
+		async function translateMany(texts, src, dst) {
+			try {
+				const clean = (Array.isArray(texts) ? texts : []).map((s) => typeof s === "string" ? s.trim() : "");
+				if (!clean.some((s) => s !== "")) return clean.map(() => null);
+				if (await ensureReady(src, dst, { userGesture: false }) !== "available") return clean.map(() => null);
+				const t = await create(src, dst);
+				if (!t) return clean.map(() => null);
+				const unique = [...new Set(clean.filter((s) => s !== ""))];
+				for (const s of unique) {
+					const rk = `${key(src, dst)}\u0000${s}`;
+					if (!results.has(rk)) {
+						const p = translateOne(t, s);
+						results.set(rk, p);
+						p.then((r) => {
+							if (r === null) results.delete(rk);
+						});
+						await p;
+					}
+				}
+				return Promise.all(clean.map((s) => s === "" ? null : results.get(`${key(src, dst)}\u0000${s}`) ?? null));
+			} catch {
+				return (Array.isArray(texts) ? texts : []).map(() => null);
+			}
+		}
+		return {
+			available,
+			ensureReady,
+			translateMany
+		};
+	}
+	//#endregion
+	//#region src/content/native-overlay.ts
+	/**
+	* Best-effort native-language line under LLL's own meanings ("coffee" → "kahve"). Finds leaf elements
+	* whose visible text equals a saved English meaning (or, when no meaning element exists for an entry,
+	* the term) and inserts one small marked span right after them. LLL's own nodes are never edited; a
+	* debounced MutationObserver re-applies after LLL re-renders. Every failure is swallowed.
+	*/
+	var NATIVE_ATTR = "data-langcoach-native";
+	var SKIP = /* @__PURE__ */ new Set([
+		"SCRIPT",
+		"STYLE",
+		"NOSCRIPT",
+		"TEMPLATE",
+		"TEXTAREA",
+		"INPUT",
+		"SELECT",
+		"OPTION",
+		"TITLE",
+		"HEAD"
+	]);
+	var MAX_ENTRIES = 1e3;
+	var MAX_TEXT = 500;
+	var norm$1 = (s) => s.replace(/\s+/g, " ").trim();
+	var termVariants = (term) => {
+		const n = norm$1(term);
+		return n.includes(" / ") ? [n, norm$1(n.split(" / ").join(" "))] : [n];
+	};
+	var isOurs = (el) => el.hasAttribute("data-langcoach-native") || el.closest("[data-langcoach-toast]") !== null;
+	function createNativeOverlay(doc, opts) {
+		const debounceMs = opts.debounceMs ?? 250;
+		/** meaning key → native; term key → native (fallback only). */
+		const byMeaning = /* @__PURE__ */ new Map();
+		const byTerm = /* @__PURE__ */ new Map();
+		let enabled = true;
+		let destroyed = false;
+		let timer;
+		let observer;
+		function makeSpan(key, native) {
+			const span = doc.createElement("span");
+			span.className = "langcoach-native";
+			span.setAttribute(NATIVE_ATTR, key);
+			span.setAttribute("dir", "auto");
+			span.setAttribute("lang", opts.lang);
+			span.style.display = "block";
+			span.style.fontSize = "0.85em";
+			span.style.lineHeight = "1.3";
+			span.style.opacity = "0.72";
+			span.style.marginTop = "2px";
+			span.style.fontStyle = "normal";
+			span.textContent = native;
+			return span;
+		}
+		function removeAll() {
+			for (const s of [...doc.querySelectorAll(`[${NATIVE_ATTR}]`)]) s.remove();
+		}
+		/** Puts `native` right after `el` (updating our existing span there); returns true if the DOM changed. */
+		function place(el, key, native) {
+			const next = el.nextElementSibling;
+			if (next && next.hasAttribute("data-langcoach-native")) {
+				if (next.getAttribute("data-langcoach-native") !== key) next.setAttribute(NATIVE_ATTR, key);
+				if (next.textContent !== native) next.textContent = native;
+				return;
+			}
+			el.after(makeSpan(key, native));
+		}
+		function apply() {
+			try {
+				if (destroyed || !doc.body) return;
+				if (!enabled || byMeaning.size === 0 && byTerm.size === 0) {
+					if (doc.querySelector(`[data-langcoach-native]`)) removeAll();
+					return;
+				}
+				const meaningHits = [];
+				const termHits = [];
+				for (const el of doc.body.querySelectorAll("*")) {
+					if (el.childElementCount !== 0 || SKIP.has(el.tagName) || isOurs(el)) continue;
+					const text = el.textContent;
+					if (!text || text.length > MAX_TEXT * 2) continue;
+					const k = norm$1(text);
+					const m = byMeaning.get(k);
+					if (m !== void 0) {
+						meaningHits.push([
+							el,
+							k,
+							m
+						]);
+						continue;
+					}
+					const t = byTerm.get(k);
+					if (t !== void 0) termHits.push([
+						el,
+						k,
+						t.native,
+						t.meaning
+					]);
+				}
+				const keep = /* @__PURE__ */ new Set();
+				const shownMeanings = new Set(meaningHits.map(([, k]) => k));
+				for (const [el, k, native] of meaningHits) {
+					place(el, k, native);
+					keep.add(el.nextElementSibling);
+				}
+				for (const [el, k, native, meaning] of termHits) {
+					if (shownMeanings.has(meaning)) continue;
+					place(el, k, native);
+					keep.add(el.nextElementSibling);
+				}
+				for (const s of [...doc.querySelectorAll(`[${NATIVE_ATTR}]`)]) if (!keep.has(s)) s.remove();
+			} catch {}
+		}
+		function schedule() {
+			if (destroyed) return;
+			if (timer !== void 0) clearTimeout(timer);
+			timer = setTimeout(() => {
+				timer = void 0;
+				apply();
+			}, debounceMs);
+		}
+		function observe() {
+			if (observer || destroyed) return;
+			try {
+				const MO = doc.defaultView?.MutationObserver;
+				if (!MO || !doc.body) return;
+				observer = new MO((records) => {
+					if (records.some((r) => {
+						const nodes = [...r.addedNodes, ...r.removedNodes];
+						if (r.type === "characterData") {
+							const p = r.target.parentElement;
+							return !(p && p.hasAttribute("data-langcoach-native"));
+						}
+						if (r.type === "childList" && r.target instanceof Element && r.target.hasAttribute("data-langcoach-native")) return false;
+						return nodes.length === 0 || nodes.some((n) => !(n instanceof Element && n.hasAttribute("data-langcoach-native")));
+					})) schedule();
+				});
+				observer.observe(doc.body, {
+					childList: true,
+					subtree: true,
+					characterData: true
+				});
+			} catch {
+				observer = void 0;
+			}
+		}
+		return {
+			add(entries) {
+				try {
+					if (destroyed || !Array.isArray(entries)) return;
+					for (const e of entries) {
+						if (!e || typeof e.meaning !== "string" || typeof e.native !== "string") continue;
+						const native = capUnits(norm$1(e.native), MAX_TEXT);
+						const meaning = norm$1(e.meaning);
+						if (!native || !meaning || meaning.length > MAX_TEXT) continue;
+						if (byMeaning.size >= MAX_ENTRIES && !byMeaning.has(meaning)) continue;
+						byMeaning.set(meaning, native);
+						if (typeof e.term === "string" && e.term.trim()) {
+							for (const v of termVariants(e.term)) if (v !== meaning) byTerm.set(v, {
+								native,
+								meaning
+							});
+						}
+					}
+					apply();
+					observe();
+				} catch {}
+			},
+			setEnabled(next) {
+				enabled = next;
+				apply();
+			},
+			destroy() {
+				destroyed = true;
+				if (timer !== void 0) clearTimeout(timer);
+				observer?.disconnect();
+				observer = void 0;
+				try {
+					removeAll();
+				} catch {}
+			}
+		};
+	}
+	var TINY_LESSON_PATH = /^\/lll\/[a-z]{2}(?:[-_][a-z]{2,4})?\/experiments\/tiny-lesson\/?$/i;
+	var SITE_HOME_PATH = /^\/lll\/[a-z]{2}(?:[-_][a-z]{2,4})?\/?$/i;
+	/** "Generate" in the LLL site languages (en, es, fr, pt). */
+	var GENERATE_TEXT = /generat|generar|g[ée]n[ée]rer|gerar/i;
+	var isTinyLessonPage = (win) => TINY_LESSON_PATH.test(win.location.pathname);
+	/** Rendered (has a layout box) and interactive. */
+	function isUsable(el) {
+		const h = el;
+		if (h.disabled || h.hidden || el.closest("[hidden], [aria-hidden=\"true\"], [inert]")) return false;
+		return el.getClientRects().length > 0;
+	}
+	/**
+	* The Tiny Lesson purpose field: exactly one usable `input` whose type is text and that is not the
+	* language combobox (live markup: no form, no maxLength, no type attribute, rotating placeholder).
+	* Anything else is ambiguous, so null; never "the first input on the page".
+	*/
+	function findPurposeField(win) {
+		const candidates = [...win.document.querySelectorAll("input")].filter((el) => el.type === "text" && el.getAttribute("role") !== "combobox" && isUsable(el));
+		return candidates.length === 1 ? candidates[0] : null;
+	}
+	/**
+	* Writes `theme` into the Tiny Lesson purpose field so that React registers it: the value goes through the
+	* element's own prototype setter (bypassing React's instance-level value tracker), then a bubbling `input`
+	* event. Returns false (and changes nothing) outside the Tiny Lesson page or when the field is not found.
+	*/
+	function fillPurposeField(win, theme) {
+		if (!isTinyLessonPage(win)) return false;
+		const el = findPurposeField(win);
+		return el ? writeValue(win, el, theme) : false;
+	}
+	function writeValue(win, el, theme) {
+		const w = win;
+		const limit = el.maxLength > 0 ? Math.min(el.maxLength, 50) : 50;
+		const value = [...theme].slice(0, limit).join("");
+		const setter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(el), "value")?.set;
+		if (!setter) return false;
+		el.focus();
+		setter.call(el, value);
+		el.dispatchEvent(new w.Event("input", { bubbles: true }));
+		return true;
+	}
+	var norm = (s) => (s ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+	function languageCombobox(win) {
+		return [...win.document.querySelectorAll("[role=\"combobox\"]")].find(isUsable) ?? null;
+	}
+	/** First visit: the intro splash ("Start" → site home) or the "Before you begin" notice (checkbox). */
+	function isSplash(win) {
+		if (languageCombobox(win)) return false;
+		const doc = win.document;
+		const toHome = [...doc.querySelectorAll("a[href]")].some((a) => {
+			try {
+				const u = new URL(a.href, win.location.href);
+				return u.origin === win.location.origin && SITE_HOME_PATH.test(u.pathname) && isUsable(a);
+			} catch {
+				return false;
+			}
+		});
+		const consent = [...doc.querySelectorAll("input[type=\"checkbox\"]")].some(isUsable);
+		return toHome || consent;
+	}
+	function selectControl(combo) {
+		return combo.closest("[class*=\"__control\"]") ?? combo.closest("[class*=\"control\"]");
+	}
+	function selectRoot(combo) {
+		return combo.closest("[class*=\"-container\"]") ?? selectControl(combo)?.parentElement ?? null;
+	}
+	function currentLanguage(combo) {
+		return norm(selectControl(combo)?.querySelector("[class*=\"single-value\"]")?.textContent);
+	}
+	async function waitFor(win, probe, timing) {
+		const end = Date.now() + timing.timeoutMs;
+		for (;;) {
+			const v = probe();
+			if (v) return v;
+			if (Date.now() >= end) return null;
+			await new Promise((r) => win.setTimeout(r, timing.stepMs));
+		}
+	}
+	function mouse(win, el, type) {
+		const w = win;
+		el.dispatchEvent(new w.MouseEvent(type, {
+			bubbles: true,
+			cancelable: true,
+			button: 0
+		}));
+	}
+	/** Chooses `label` in the react-select picker; true when the control then shows it. */
+	async function chooseLanguage(win, combo, label, timing) {
+		const want = norm(label);
+		if (currentLanguage(combo) === want) return true;
+		const control = selectControl(combo);
+		if (!control) return false;
+		mouse(win, control, "mousedown");
+		const options = await waitFor(win, () => {
+			const list = [...win.document.querySelectorAll("[role=\"listbox\"] [role=\"option\"]")];
+			return list.length > 0 ? list : null;
+		}, timing);
+		const option = options?.find((o) => norm(o.textContent) === want);
+		if (!option) {
+			if (options) mouse(win, control, "mousedown");
+			return false;
+		}
+		mouse(win, option, "mousedown");
+		mouse(win, option, "mouseup");
+		option.click();
+		return await waitFor(win, () => currentLanguage(combo) === want, timing) === true;
+	}
+	/** The Generate button: after the purpose field, outside the picker, labelled Generate (or the only one). */
+	function findGenerate(win, purpose, combo) {
+		const picker = combo ? selectRoot(combo) : null;
+		const after = [...win.document.querySelectorAll("button")].filter((b) => purpose.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING && !(picker && picker.contains(b)) && b.getClientRects().length > 0);
+		const named = after.find((b) => GENERATE_TEXT.test(b.textContent ?? "") || GENERATE_TEXT.test(b.getAttribute("aria-label") ?? ""));
+		if (named) return named;
+		for (let box = purpose.parentElement; box && box !== win.document.body; box = box.parentElement) {
+			const inBox = after.filter((b) => box.contains(b));
+			if (inBox.length === 1) return inBox[0];
+			if (inBox.length > 1) return null;
+		}
+		return null;
+	}
+	var enabled = (b) => !b.disabled && b.getAttribute("aria-disabled") !== "true";
+	/**
+	* Starts a Tiny Lesson for `theme`: (a) splash → reason 'splash'; (b) select the target language when it
+	* differs; (c) fill the purpose (≤50 chars, React-safe); (d) wait ≤timeout for Generate, click it.
+	*/
+	async function startScenario(win, req, timingIn = {}) {
+		const timing = {
+			timeoutMs: timingIn.timeoutMs ?? 3e3,
+			stepMs: timingIn.stepMs ?? 50
+		};
+		try {
+			if (!isTinyLessonPage(win)) return {
+				ok: false,
+				reason: "not_tiny_lesson"
+			};
+			await waitFor(win, () => isSplash(win) || !!findPurposeField(win), timing);
+			if (isSplash(win)) return {
+				ok: false,
+				reason: "splash"
+			};
+			if (!findPurposeField(win)) return {
+				ok: false,
+				reason: "field"
+			};
+			const combo = languageCombobox(win);
+			if (req.targetLabel) {
+				if (!combo || !await chooseLanguage(win, combo, req.targetLabel, timing)) return {
+					ok: false,
+					reason: "language"
+				};
+			}
+			const purpose = findPurposeField(win);
+			if (!purpose || !writeValue(win, purpose, req.theme)) return {
+				ok: false,
+				reason: "field"
+			};
+			const button = await waitFor(win, () => {
+				const b = findGenerate(win, purpose, combo);
+				return b && enabled(b) ? b : null;
+			}, timing);
+			if (!button) return {
+				ok: false,
+				reason: "generate"
+			};
+			button.click();
+			return { ok: true };
+		} catch {
+			return {
+				ok: false,
+				reason: "error"
+			};
+		}
+	}
+	//#endregion
+	//#region src/content/protocol.ts
+	/** Attribute the isolated script sets on <html> to hand the per-page nonce to the MAIN-world script. */
+	var NONCE_ATTR = "data-langcoach-nonce";
+	//#endregion
+	//#region src/content/toast.ts
+	var TOAST_MS = 6e3;
+	var CSS = `
+:host { all: initial; }
+.box {
+  position: fixed;
+  left: 16px;
+  bottom: 16px;
+  z-index: 2147483647;
+  max-width: 360px;
+  box-sizing: border-box;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 8px 12px;
+  padding: 10px 14px;
+  border-radius: 14px;
+  font: 500 14px/1.4 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  color: #1d2433;
+  background: #ffffff;
+  border: 1px solid #d9dee8;
+  box-shadow: 0 6px 24px rgba(16, 24, 40, 0.18);
+}
+.text { flex: 1 1 auto; min-width: 0; overflow-wrap: anywhere; }
+.actions { display: flex; gap: 6px; }
+button {
+  font: inherit;
+  font-weight: 600;
+  cursor: pointer;
+  padding: 4px 10px;
+  border-radius: 999px;
+  border: 1px solid #b9c3d6;
+  background: #f2f5fb;
+  color: #1a4fd6;
+}
+button:hover { background: #e4ebfa; }
+button:focus-visible { outline: 3px solid #1a4fd6; outline-offset: 2px; }
+@media (prefers-color-scheme: dark) {
+  .box { color: #e8ecf4; background: #1f2430; border-color: #3a4256; box-shadow: 0 6px 24px rgba(0, 0, 0, 0.5); }
+  button { color: #9ec0ff; background: #2a3142; border-color: #4a5470; }
+  button:hover { background: #343c50; }
+  button:focus-visible { outline-color: #9ec0ff; }
+}
+@media (prefers-reduced-motion: no-preference) {
+  .box { animation: in 160ms ease-out; }
+  @keyframes in { from { opacity: 0; transform: translateY(8px); } to { opacity: 1; transform: none; } }
+}
+`;
+	/**
+	* One toast at a time, bottom-left (clear of the lesson page's main buttons), in a closed shadow
+	* root on a host appended to <html>. Auto-hides after 6 s; hovering or focusing it pauses the timer.
+	*/
+	function createToaster(doc = document, duration = TOAST_MS) {
+		let host = null;
+		let root = null;
+		let timer;
+		let deadline = 0;
+		let remaining = duration;
+		let hovered = false;
+		let focused = false;
+		const clear = () => {
+			if (timer !== void 0) clearTimeout(timer);
+			timer = void 0;
+		};
+		const start = (ms) => {
+			clear();
+			remaining = ms;
+			deadline = Date.now() + ms;
+			timer = setTimeout(hide, ms);
+		};
+		const pause = () => {
+			if (timer === void 0) return;
+			remaining = Math.max(0, deadline - Date.now());
+			clear();
+		};
+		const resume = () => {
+			if (!hovered && !focused && host) start(remaining);
+		};
+		function hide() {
+			clear();
+			try {
+				host?.remove();
+			} catch {}
+			host = null;
+			root = null;
+			hovered = focused = false;
+		}
+		function show(spec) {
+			hide();
+			const h = doc.createElement("div");
+			h.setAttribute("data-langcoach-toast", "");
+			const r = h.attachShadow({ mode: "closed" });
+			const style = doc.createElement("style");
+			style.textContent = CSS;
+			const box = doc.createElement("div");
+			box.className = "box";
+			box.setAttribute("role", "status");
+			box.setAttribute("aria-live", "polite");
+			const text = doc.createElement("span");
+			text.className = "text";
+			text.textContent = spec.text;
+			box.append(text);
+			if (spec.actions?.length) {
+				const actions = doc.createElement("span");
+				actions.className = "actions";
+				for (const a of spec.actions) {
+					const b = doc.createElement("button");
+					b.type = "button";
+					b.textContent = a.label;
+					b.addEventListener("click", (e) => {
+						e.stopPropagation();
+						a.onClick();
+					});
+					actions.append(b);
+				}
+				box.append(actions);
+			}
+			r.append(style, box);
+			h.addEventListener("mouseenter", () => {
+				hovered = true;
+				pause();
+			});
+			h.addEventListener("mouseleave", () => {
+				hovered = false;
+				resume();
+			});
+			h.addEventListener("focusin", () => {
+				focused = true;
+				pause();
+			});
+			h.addEventListener("focusout", () => {
+				focused = false;
+				resume();
+			});
+			doc.documentElement.append(h);
+			host = h;
+			root = r;
+			start(duration);
+		}
+		return {
+			show,
+			hide,
+			get root() {
+				return root;
+			}
+		};
+	}
+	//#endregion
+	//#region src/content/isolated.ts
+	var KINDS = [
+		"terms",
+		"grammar",
+		"conversation",
+		"object-descriptors"
+	];
+	var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+	function randomNonce(win) {
+		const b = /* @__PURE__ */ new Uint8Array(16);
+		win.crypto.getRandomValues(b);
+		return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+	}
+	/**
+	* Isolated-world entry (document_start). Publishes a per-page nonce for the MAIN-world script, accepts
+	* only same-window, same-origin captures carrying that nonce, relays them to the background and shows
+	* the result as a toast. A page script that reads the nonce could still forge a capture; the worst it
+	* can do is add vocabulary to the learner's own deck.
+	*/
+	function startIsolated(deps) {
+		const { win, t } = deps;
+		const toaster = deps.toaster ?? createToaster(win.document);
+		const nonce = randomNonce(win);
+		win.document.documentElement.setAttribute(NONCE_ATTR, nonce);
+		/** Resolves to the response data, or undefined on any failure (errors stay in the extension). */
+		async function ask(msg) {
+			try {
+				const res = await deps.sendMessage(msg);
+				return res && res.ok ? res.data : void 0;
+			} catch {
+				return;
+			}
+		}
+		const openAction = () => ({
+			label: t("toastOpen"),
+			onClick: () => {
+				ask({ type: "openPanel" });
+				toaster.hide();
+			}
+		});
+		const translator = deps.translator ?? createTranslatorCache();
+		let overlay = null;
+		let overlayLang = "";
+		let showOnPage = true;
+		function overlayFor(lang) {
+			if (!overlay || overlayLang !== lang) {
+				overlay?.destroy();
+				overlay = createNativeOverlay(win.document, {
+					lang,
+					debounceMs: deps.overlayDebounceMs
+				});
+				overlayLang = lang;
+			}
+			overlay.setEnabled(showOnPage);
+			return overlay;
+		}
+		try {
+			deps.onShowNativeChanged?.((show) => {
+				showOnPage = show;
+				overlay?.setEnabled(show);
+			});
+		} catch {}
+		const str = (v) => typeof v === "string" && v.trim() !== "";
+		/**
+		* After the background saved a capture: translate meanings that have no native translation yet (only
+		* when the model is already on this device; no download without a click), store them, and show them
+		* under LLL's meanings. Grammar examples are only shown, not stored. Any failure leaves English as is.
+		*/
+		async function applyNative(r) {
+			try {
+				const hint = r.native;
+				if (!isObj(hint) || !str(hint.source) || !str(hint.target)) return;
+				const { source, target } = hint;
+				if (typeof hint.overlay === "boolean") showOnPage = hint.overlay;
+				const shown = [];
+				if (r.status === "saved") {
+					const items = (Array.isArray(hint.items) ? hint.items : []).filter((i) => isObj(i) && str(i.cardId) && str(i.meaning)).map((i) => ({
+						cardId: i.cardId,
+						term: typeof i.term === "string" ? i.term : "",
+						meaning: i.meaning,
+						native: str(i.native) ? i.native : void 0
+					}));
+					if (items.length === 0) return;
+					const missing = items.filter((i) => !i.native);
+					const out = missing.length ? await translator.translateMany(missing.map((i) => i.meaning), source, target) : [];
+					const entries = [];
+					missing.forEach((i, k) => {
+						const text = out[k];
+						if (text) {
+							i.native = text;
+							entries.push({
+								cardId: i.cardId,
+								text
+							});
+						}
+					});
+					if (entries.length) ask({
+						type: "setNativeTranslations",
+						entries: entries.slice(0, 500)
+					});
+					for (const i of items) if (i.native) shown.push({
+						term: i.term,
+						meaning: i.meaning,
+						native: i.native
+					});
+				} else if (r.status === "grammar") {
+					const examples = (Array.isArray(hint.examples) ? hint.examples : []).filter(str).slice(0, 100);
+					const out = examples.length ? await translator.translateMany(examples, source, target) : [];
+					examples.forEach((ex, k) => {
+						const text = out[k];
+						if (text) shown.push({
+							meaning: ex,
+							native: text
+						});
+					});
+				}
+				if (shown.length) overlayFor(target).add(shown);
+			} catch {}
+		}
+		function withXp(text, xp) {
+			return xp > 0 ? `${text} · ${t("toastXp", String(xp))}` : text;
+		}
+		function showResult(r, capture) {
+			if (!isObj(r)) return;
+			if (r.status === "saved" || r.status === "grammar") applyNative(r);
+			if (r.status === "pending") {
+				toaster.show({
+					text: t("extName"),
+					actions: [{
+						label: t("toastSaveN", String(r.count)),
+						onClick: () => {
+							toaster.hide();
+							ask({
+								...capture,
+								force: true
+							}).then((res) => showResult(res, capture));
+						}
+					}]
+				});
+				return;
+			}
+			if (r.status !== "saved") return;
+			const sent = (text) => r.forwarded === true ? `${text} · ${t("toastForwarded")}` : text;
+			if (r.newCards === 0) {
+				toaster.show({
+					text: withXp(sent(t("toastAlready")), r.xp),
+					actions: [openAction()]
+				});
+				return;
+			}
+			const lessonIds = r.lessonIds;
+			toaster.show({
+				text: withXp(sent(t("toastSaved", String(r.newCards))), r.xp),
+				actions: [{
+					label: t("toastUndo"),
+					onClick: () => {
+						toaster.hide();
+						ask({
+							type: "undo",
+							lessonIds
+						}).then((u) => {
+							if (u) toaster.show({ text: t("toastRemoved") });
+						});
+					}
+				}, openAction()]
+			});
+		}
+		win.addEventListener("message", (e) => {
+			try {
+				if (e.source !== win || e.origin !== win.location.origin) return;
+				const d = e.data;
+				if (!isObj(d) || d.nonce !== nonce) return;
+				if (d.source === "langcoach-ack") {
+					win.document.documentElement.removeAttribute(NONCE_ATTR);
+					return;
+				}
+				if (d.source !== "langcoach-capture" || !KINDS.includes(d.kind)) return;
+				const capture = {
+					type: "capture",
+					kind: d.kind,
+					request: d.request,
+					response: d.response,
+					pageUrl: win.location.href
+				};
+				ask(capture).then((r) => showResult(r, capture));
+			} catch {}
+		});
+		deps.onMessage.addListener((msg, sender, sendResponse) => {
+			if (sender?.id !== deps.runtimeId || !isObj(msg)) return;
+			if (msg.type === "ping") {
+				sendResponse?.({ ready: true });
+				return;
+			}
+			if (msg.type === "startScenario") {
+				if (!(typeof msg.theme === "string" && msg.theme.trim() !== "" && (msg.targetLabel === void 0 || typeof msg.targetLabel === "string"))) {
+					sendResponse?.({
+						ok: false,
+						reason: "invalid"
+					});
+					return;
+				}
+				startScenario(win, {
+					theme: msg.theme,
+					...typeof msg.targetLabel === "string" && msg.targetLabel ? { targetLabel: msg.targetLabel } : {}
+				}).catch(() => ({
+					ok: false,
+					reason: "error"
+				})).then((r) => {
+					try {
+						sendResponse?.(r);
+					} catch {}
+				});
+				return true;
+			}
+			if (msg.type === "fillTheme" && typeof msg.theme === "string") {
+				let filled = false;
+				try {
+					filled = fillPurposeField(win, msg.theme);
+				} catch {}
+				sendResponse?.({ filled });
+				return;
+			}
+			if (msg.type !== "toast") return;
+			if (msg.variant === "manual") toaster.show({
+				text: t("toastSavedManual"),
+				actions: [openAction()]
+			});
+			else if (msg.variant === "already") toaster.show({
+				text: t("toastAlready"),
+				actions: [openAction()]
+			});
+		});
+		return {
+			nonce,
+			/** Removes the native-language lines and stops observing the page (tests, extension reload). */
+			dispose: () => {
+				overlay?.destroy();
+				overlay = null;
+			}
+		};
+	}
+	//#endregion
+	//#region src/content-isolated.ts
+	/** Same key as background/router.ts SETTINGS_KEY (not imported: keeps the background out of this bundle). */
+	var SETTINGS_KEY = "langcoach:settings";
+	startIsolated({
+		win: window,
+		runtimeId: chrome.runtime.id,
+		sendMessage: (msg) => chrome.runtime.sendMessage(msg),
+		onMessage: chrome.runtime.onMessage,
+		t: (key, subs) => chrome.i18n.getMessage(key, subs),
+		onShowNativeChanged: (cb) => {
+			try {
+				chrome.storage.onChanged.addListener((changes, area) => {
+					const next = changes[SETTINGS_KEY]?.newValue;
+					if (area === "local" && next && typeof next === "object") cb(next.showNativeOnPage !== false);
+				});
+			} catch {}
+		}
+	});
+	//#endregion
+})();