test(02-06): language bridge parity under both transports

- test_language_bridge_under_both_transports, parametrised over inline and
iframe: analyze() returns the golden records for the avatar's and a learner's
line, translate() returns the contract sentence and stamps the debug slice,
languageInfo() reports the loaded assets and a finished warm-up, the turn
event carries the directive's tokens, and refused requests surface as
rejections carrying the server's words

tests/e2e/test_facade_parity.py

@@ -502,3 +502,150 @@ def test_gesture_unlocks_audio_under_both_transports(
         assert after["turnCount"] == 1
         assert not after["speaking"] and not after["thinking"]
         assert numbers["audio_duration"] and numbers["audio_duration"] > 1.0
+
+
+# ------------------------------------------------------------- the language bridge (02-06)
+
+# Every reading here comes from the golden fixture (tests/fixtures/sentences.json): 食べました
+# is ONE tappable unit with lemma 食べる; 今日 reads きょう (not こんにち); the particle は is
+# plain text (D-11). 駅はどこですか。 is the six-sentence MT contract's "station" line.
+EAT = "食べました"
+WEATHER = "今日はいい天気ですね。"
+STATION = "駅はどこですか。"
+
+REJECTION = """
+async ([name, arg]) => {
+  try {
+    await window.Avatar[name](arg);
+    return null;
+  } catch (err) {
+    return String((err && err.message) || err);
+  }
+}
+"""
+
+LANGUAGE_DEBUG = """
+async () => {
+  const d = await window.Avatar.getDebug();
+  return {
+    analyzeCount: d.analyzeCount, lastAnalyzeMs: d.lastAnalyzeMs,
+    translateCount: d.translateCount, lastTranslateMs: d.lastTranslateMs,
+    lastTranslation: d.lastTranslation, lastTranslateError: d.lastTranslateError,
+    lastTokenCount: d.lastTokenCount, languageInfoCached: d.languageInfo !== null,
+    transport: d.transport,
+  };
+}
+"""
+
+
+def _unit(tokens: list[dict], surface: str) -> dict:
+    matches = [t for t in tokens if t["surface"] == surface]
+    assert len(matches) == 1, (
+        f"{surface!r} is not exactly one unit in {[t['surface'] for t in tokens]}"
+    )
+    return matches[0]
+
+
+@pytest.mark.parametrize("transport", TRANSPORTS)
+def test_language_bridge_under_both_transports(transport, page, gradio_apps, speech_events):
+    """Plan 02-06: tokens, translation and asset facts cross the bridge identically under
+    inline and iframe, proven against live objects before a single DOM node is written.
+
+    Five things, each a number or an exact string: analyze() returns the golden records;
+    translate() returns the contract sentence and stamps the debug slice; languageInfo()
+    reports the loaded assets and a finished warm-up; the turn event carries the tokens the
+    directive carried; and a refused request surfaces as an ordinary rejection carrying the
+    server's own words, never as `undefined`.
+    """
+    url = gradio_apps(transport)
+    speech_events.install(page)
+    page.goto(url)
+    page.wait_for_function(AVATAR_READY, timeout=BOOT_TIMEOUT_MS)
+    page.wait_for_function(FIRST_FRAME, timeout=FIRST_FRAME_TIMEOUT_MS)
+    assert page.evaluate("() => window.Avatar.__debug.transport") == transport
+
+    # 1. analyze - the avatar's line and a learner-style line.
+    eat = page.evaluate("(t) => window.Avatar.analyze(t)", EAT)
+    print(f"[{transport}] analyze({EAT!r}): {eat['timings']}")
+    assert len(eat["tokens"]) == 1, eat["tokens"]
+    token = eat["tokens"][0]
+    assert token["lemma"] == "食べる" and token["tappable"] is True
+    assert token["gloss"], "the gloss rides inside the token (no lookup round trip)"
+    assert token["reading"] == "たべました" and token["jlpt"] == "N5"
+
+    weather = page.evaluate("(t) => window.Avatar.analyze(t)", WEATHER)
+    surfaces = [t["surface"] for t in weather["tokens"]]
+    print(f"[{transport}] analyze({WEATHER!r}): {surfaces} in {weather['timings']}")
+    assert "".join(surfaces) == WEATHER, "the surfaces must tile the text"
+    kyou = _unit(weather["tokens"], "今日")
+    assert kyou["reading"] == "きょう" and kyou["tappable"] is True
+    assert _unit(weather["tokens"], "は")["tappable"] is False
+
+    # 2. translate - the contract sentence, filed under a line id, timed on both sides.
+    translated = page.evaluate("([t, id]) => window.Avatar.translate(t, id)", [STATION, "L1"])
+    print(
+        f"[{transport}] translate({STATION!r}) -> {translated['text']!r} in "
+        f"{translated['ms']} ms (server {translated['timings']})"
+    )
+    assert "station" in translated["text"].lower(), translated["text"]
+    assert translated["lineId"] == "L1"
+    assert translated["ms"] > 0
+    assert translated["timings"]["translate_ms"] > 0
+    debug = page.evaluate(LANGUAGE_DEBUG)
+    print(f"[{transport}] language debug after translate: {debug}")
+    assert debug["transport"] == transport
+    assert debug["analyzeCount"] == 2 and debug["lastAnalyzeMs"] is not None
+    assert debug["translateCount"] == 1 and debug["lastTranslateMs"] > 0
+    assert debug["lastTranslation"] == translated["text"]
+    assert debug["lastTranslateError"] is None
+
+    # 3. languageInfo - the assets are loaded and the load warm-up ran to completion.
+    info = page.evaluate("() => window.Avatar.languageInfo()")
+    print(
+        f"[{transport}] languageInfo: jmdict_entries={info['jmdict_entries']} "
+        f"jmdict_bytes={info['jmdict_bytes']} tokenizer_dict_bytes={info['tokenizer_dict_bytes']} "
+        f"mt_model_bytes={info['mt_model_bytes']} rss_mb={info['rss_mb']} "
+        f"cpu_cores={info['cpu_cores']} memory={info['memory']} warm={info['warm']} "
+        f"pins={info['pins']}"
+    )
+    assert info["jmdict_entries"] == 218672
+    assert info["mt_model_bytes"] > 70_000_000
+    assert info["tokenizer_dict_bytes"] > 100_000_000
+    assert isinstance(info["warm"]["total_s"], int | float)
+    assert info["warm"]["expected_rss_delta_mb"] == 410
+    assert info["warm"]["errors"] == []
+    assert page.evaluate(LANGUAGE_DEBUG)["languageInfoCached"] is True
+
+    # 4. the turn event carries the directive's tokens. Synthesis is slow under SwiftShader,
+    # so the promise is parked on the window and the event is waited for with the turn budget.
+    page.evaluate(
+        "(t) => { window.__turn = window.Avatar.dispatchTurn(t)"
+        ".catch((e) => ({ error: String((e && e.message) || e) })); }",
+        EAT,
+    )
+    turn_events = speech_events.wait_for(page, "turn", timeout_ms=TURN_TIMEOUT_MS)
+    outcome = page.evaluate("() => window.__turn")
+    if outcome and outcome.get("error"):
+        pytest.importorskip("voicevox_core")
+        pytest.fail(f"{transport}: dispatchTurn rejected: {outcome['error']}")
+    event_tokens = turn_events[-1]["data"]["tokens"]
+    print(
+        f"[{transport}] turn event tokens: {[t['surface'] for t in event_tokens]}; "
+        f"timings {turn_events[-1]['data']['timings']}"
+    )
+    assert len(event_tokens) == 1 and event_tokens[0]["lemma"] == "食べる"
+    assert turn_events[-1]["data"]["timings"]["analyze_ms"] >= 0
+    assert page.evaluate(LANGUAGE_DEBUG)["lastTokenCount"] == 1
+    _wait_settled(page)
+
+    # 5. the error contract: the server's {error} arrives as a rejection with its words.
+    empty = page.evaluate(REJECTION, ["analyze", ""])
+    too_long = page.evaluate(REJECTION, ["translate", "あ" * 201])
+    print(
+        f"[{transport}] rejections: analyze('') -> {empty!r}; translate(201 chars) -> {too_long!r}"
+    )
+    assert empty is not None and "text is required" in empty
+    assert too_long is not None and "characters" in too_long
+    after = page.evaluate(LANGUAGE_DEBUG)
+    assert after["translateCount"] == 1, "a refused translate is not a translation"
+    assert after["lastTranslateError"] is not None and "characters" in after["lastTranslateError"]