@oniisan/htvoffcial 0.1.1

package/discuss_readme_coach.mjs

@@ -0,0 +1,571 @@
+/*
+ Copyright (C) 2026 htvoffcial
+ SPDX-License-Identifier: SSPL-1.0
+
+ This program is free software: you can use, redistribute,
+ and/or modify it under the terms of the Server Side
+ Public License, version 1, as published by MongoDB, Inc.
+*/
+/*
+- 「昨日のまとめ」に対する優しいツッコミ,任意で！,タイトルと本文の齟齬くらいは無視！（コメディアン寄り）
+*/
+import fs from "node:fs";
+
+const GH_TOKEN = process.env.GH_TOKEN;
+const CF_ACCOUNT_ID = process.env.CF_ACCOUNT_ID;
+const CF_API_TOKEN = process.env.CF_API_TOKEN;
+
+if (!GH_TOKEN) throw new Error("GH_TOKEN is missing");
+if (!CF_ACCOUNT_ID) throw new Error("CF_ACCOUNT_ID is missing");
+if (!CF_API_TOKEN) throw new Error("CF_API_TOKEN is missing");
+
+const OWNER = process.env.GITHUB_REPOSITORY_OWNER;
+const REPO = (process.env.GITHUB_REPOSITORY || "").split("/")[1];
+
+if (!OWNER || !REPO) throw new Error("Missing GITHUB_REPOSITORY(_OWNER) env");
+
+const CF_MODEL = "@cf/google/gemma-4-26b-a4b-it";
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// 気象庁アメダス（bosai）簡易ユーティリティ
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+/**
+ * 気象庁アメダス bosai の point データは 3時間ごとのファイルに分割されている。
+ * 例) YYYYMMDD_00,03,06,...,21
+ * @param {string} yyyymmdd
+ * @returns {string[]}
+ */
+function amedasH3List(yyyymmdd) {
+  return ["00", "03", "06", "09", "12", "15", "18", "21"].map((hh) => `${yyyymmdd}_${hh}`);
+}
+
+/**
+ * @param {string} s
+ * @returns {string}
+ */
+function pad2(s) {
+  return String(s).padStart(2, "0");
+}
+
+/**
+ * JST日付(YYYY-MM-DD) → 気象庁アメダス用(YYYYMMDD)
+ * @param {string} dayJst
+ */
+function toYyyymmdd(dayJst) {
+  return dayJst.replaceAll("-", "");
+}
+
+/**
+ * ざっくり「代表天気」を作る。
+ * アメダスは WMO weathercode を返さないので、
+ * 日中(6-18時)の1時間降水量の有無で晴/雨を判定し、
+ * 欠測が多い場合は unknown。
+ *
+ * @param {{hour:number, precipitation1hMm:number|null}[]} hourly
+ * @returns {{code:number, label:string, icon:string, category:string, isSunny:boolean, isRainy:boolean, isCloudy:boolean, isSnowy:boolean, isStormy:boolean}}
+ */
+function dominantWeatherFromAmedas(hourly) {
+  const daytime = hourly.filter((x) => x.hour >= 6 && x.hour <= 18);
+
+  const valid = daytime.filter((x) => typeof x.precipitation1hMm === "number");
+  const rainy = valid.filter((x) => (x.precipitation1hMm ?? 0) > 0);
+
+  // ベストエフォート判定
+  // - validが1つでもあり、雨が1回でもあれば「雨」
+  // - validがある程度(>=3)あり、雨が0なら「晴」
+  // - それ以外は「不明」
+  if (valid.length < 6) {
+    if (rainy.length >= 1) {
+      return {
+        code: 61,
+        label: "雨（アメダス判定・簡易）",
+        icon: "🌧️",
+        category: "rain",
+        isSunny: false,
+        isRainy: true,
+        isCloudy: false,
+        isSnowy: false,
+        isStormy: false,
+      };
+    }
+
+    if (valid.length >= 3) {
+      return {
+        code: 0,
+        label: "晴（アメダス判定・簡易）",
+        icon: "☀️",
+        category: "sunny",
+        isSunny: true,
+        isRainy: false,
+        isCloudy: false,
+        isSnowy: false,
+        isStormy: false,
+      };
+    }
+
+    return {
+      code: -1,
+      label: "不明",
+      icon: "❓",
+      category: "unknown",
+      isSunny: false,
+      isRainy: false,
+      isCloudy: false,
+      isSnowy: false,
+      isStormy: false,
+    };
+  }
+
+  // データが十分ある場合は従来通り
+  if (rainy.length >= 1) {
+    return {
+      code: 61,
+      label: "雨（アメダス判定）",
+      icon: "🌧️",
+      category: "rain",
+      isSunny: false,
+      isRainy: true,
+      isCloudy: false,
+      isSnowy: false,
+      isStormy: false,
+    };
+  }
+
+  return {
+    code: 0,
+    label: "晴（アメダス判定）",
+    icon: "☀️",
+    category: "sunny",
+    isSunny: true,
+    isRainy: false,
+    isCloudy: false,
+    isSnowy: false,
+    isSnowy: false,
+    isStormy: false,
+  };
+}
+
+/**
+ * AQC付きの値配列から数値を取り出す。
+ * bosai/amedas の多くの要素は [value, aqc] 形式。
+ *
+ * ただしフィールド/時期によっては「直値(number)」で返ることがある。
+ * 例: precipitation1h: 0
+ *
+ * @param {unknown} v
+ * @returns {number|null}
+ */
+function readAmedasNumber(v) {
+  if (typeof v === "number") return v;
+
+  if (!Array.isArray(v)) return null;
+  const value = v[0];
+  const aqc = v[1];
+
+  if (value == null) return null;
+  if (typeof value !== "number") return null;
+
+  if (typeof aqc === "number" && aqc !== 0) return null;
+
+  return value;
+}
+
+/**
+ * 気象庁 bosai アメダス から、指定日の時系列(10分刻み)を取得し、1時間降水量ベースの簡易サマリーを返す。
+ *
+ * @param {{amedasPoint:string, dayJst:string}} params
+ * @returns {Promise<{dominantWeather: ReturnType<typeof dominantWeatherFromAmedas>, rainyHoursCount:number}>}
+ */
+async function getAmedasDominantWeatherForDay({ amedasPoint, dayJst }) {
+  const yyyymmdd = toYyyymmdd(dayJst);
+
+  const base = "https://www.jma.go.jp/bosai/amedas/data/point";
+
+  // 3時間ごとのJSONを全部取ってマージする
+  const urls = amedasH3List(yyyymmdd).map((h3) => `${base}/${amedasPoint}/${h3}.json`);
+
+  /** @type {Record<string, any>} */
+  const merged = {};
+  let okCount = 0;
+  let skipCount = 0;
+
+  for (const url of urls) {
+    const res = await fetch(url);
+
+    if (!res.ok) {
+      console.warn(`AMeDAS fetch skipped: ${res.status} ${url}`);
+      skipCount++;
+      continue;
+    }
+    okCount++;
+
+    const json = await res.json().catch(() => null);
+    if (!json || typeof json !== "object") continue;
+
+    for (const [t, v] of Object.entries(json)) merged[t] = v;
+  }
+
+  console.log(
+    `AMeDAS fetch summary: ok=${okCount}/${urls.length} skipped=${skipCount} mergedKeys=${Object.keys(merged).length}`
+  );
+
+  /** @type {Map<number, number|null>} */
+  const precipByHour = new Map();
+
+  for (const t of Object.keys(merged).sort()) {
+    // 気象庁のpointデータのキーは "YYYYMMDDHHMMSS" (例: "20260523090000") の形式
+    let hourJst;
+    if (/^\d{14}$/.test(t)) {
+      // 8文字目から2文字分（時間）を取得
+      hourJst = Number(t.substring(8, 10));
+    } else {
+      // 万が一将来フォーマットが変わったときのフォールバック用
+      const dt = new Date(t);
+      const m = t.match(/T(\d{2}):/);
+      hourJst = m ? Number(m[1]) : dt.getUTCHours();
+    }
+
+    const p1h = readAmedasNumber(merged[t]?.precipitation1h);
+
+    if (typeof p1h === "number") {
+      precipByHour.set(hourJst, p1h);
+    } else {
+      if (!precipByHour.has(hourJst)) precipByHour.set(hourJst, null);
+    }
+  }
+
+  const hourly = [];
+  for (let h = 0; h < 24; h++) {
+    hourly.push({
+      hour: h,
+      precipitation1hMm: precipByHour.has(h) ? precipByHour.get(h) : null,
+    });
+  }
+
+  const daytime = hourly.filter((x) => x.hour >= 6 && x.hour <= 18);
+  const daytimeValid = daytime.filter((x) => typeof x.precipitation1hMm === "number").length;
+  console.log(`AMeDAS daytime valid points: ${daytimeValid}/13`);
+
+  const dominantWeather = dominantWeatherFromAmedas(hourly);
+
+  const rainyHoursCount = hourly
+    .filter((x) => x.hour >= 6 && x.hour <= 18)
+    .filter((x) => (x.precipitation1hMm ?? 0) > 0).length;
+
+  return { dominantWeather, rainyHoursCount };
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+// JSTの「昨日」範囲をUTCに変換
+function getYesterdayJstRangeUtc() {
+  const now = new Date();
+  const nowJst = new Date(now.getTime() + 9 * 60 * 60 * 1000);
+  const y = new Date(Date.UTC(nowJst.getUTCFullYear(), nowJst.getUTCMonth(), nowJst.getUTCDate() - 1));
+  const yyyy = y.getUTCFullYear();
+  const mm = String(y.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(y.getUTCDate()).padStart(2, "0");
+  const dayJst = `${yyyy}-${mm}-${dd}`;
+
+  const startUtc = new Date(`${dayJst}T00:00:00+09:00`).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const endUtc = new Date(`${dayJst}T23:59:59+09:00`).toISOString().replace(/\.\d{3}Z$/, "Z");
+
+  return { dayJst, startUtc, endUtc };
+}
+
+async function safeFetchText(url, { timeoutMs = 10000, retries = 2 } = {}) {
+  let lastErr;
+
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const res = await fetch(url, {
+        method: "GET",
+        signal: controller.signal,
+      });
+
+      const text = await res.text();
+      return { res, text };
+    } catch (e) {
+      lastErr = e;
+
+      if (attempt < retries) {
+        const backoffMs = 500 * (attempt + 1);
+        await new Promise((r) => setTimeout(r, backoffMs));
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  throw lastErr;
+}
+
+async function getNawatobi(dayJst) {
+  try {
+    const { res, text: csvText } = await safeFetchText("https://harutv.stars.ne.jp/jumprope/count.csv", {
+      timeoutMs: 12000,
+      retries: 2,
+    });
+
+    if (!res.ok) {
+      throw new Error(`NawatobiGetError error: ${res.status} ${csvText}`);
+    }
+
+    const data = {};
+    const lines = csvText.split(/\r?\n/);
+    for (const line of lines) {
+      const [key, ...valueParts] = line.split(":");
+      if (key && valueParts.length > 0) {
+        data[key.trim()] = valueParts.join(":").trim();
+      }
+    }
+
+    if (!data.lastmodified || !data.count) {
+      throw new Error("CSVのデータ形式が不正です。");
+    }
+
+    // 1. CSVの "2026/07/04 18:03(+09:00)" から日付部分（スペースより前）だけを切り出す
+    const csvDatePart = data.lastmodified.split(" ")[0]; // -> "2026/07/04"
+
+    // 2. スラッシュをハイフンに変換して形式を統一する
+    const csvDateJst = csvDatePart.replaceAll("/", "-"); // -> "2026-07-04"
+
+    // 3. 対象日（dayJst）とCSVの更新日が完全に一致するか判定する
+    if (csvDateJst === dayJst) {
+      return data.count + "回";
+    } else {
+      return "お休み(0回)";
+    }
+  } catch (e) {
+    console.warn(`Nawatobi fetch/parse failed. fallback=お休み(0回) reason=${String(e?.message || e)}`);
+    return "お休み(0回)";
+  }
+}
+async function ghGraphql(query, variables) {
+  const res = await fetch("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: `bearer ${GH_TOKEN}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`GitHub GraphQL error: ${res.status} ${text}`);
+  }
+  return res.json();
+}
+
+function clampText(s, maxChars) {
+  if (!s) return "";
+  const t = s.replace(/\r\n/g, "\n").trim();
+  if (t.length <= maxChars) return t;
+  return t.slice(0, maxChars) + "…(省略)";
+}
+
+// トークン（コスト）節約：本文をカットして合計も制限
+function buildPromptSource(discussions, { maxPerBodyChars = 800, maxTotalChars = 3500 } = {}) {
+  let total = 0;
+  const lines = [];
+
+  for (const d of discussions) {
+    const body = clampText(d.bodyText || "", maxPerBodyChars);
+    const chunk = `【${d.title}】
+URL: ${d.url}
+本文(抜粋):
+${body}
+`;
+    if (total + chunk.length > maxTotalChars) break;
+    lines.push(chunk);
+    total += chunk.length;
+  }
+
+  return { source: lines.join("\n"), usedChars: total };
+}
+
+async function cfAiChat({ accountId, apiToken, model, messages, temperature}) {
+  const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}`;
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ messages, temperature }),
+  });
+
+  const json = await res.json().catch(() => null);
+
+  if (!res.ok || json?.success === false) {
+    const err = JSON.stringify(json ?? { status: res.status }, null, 2);
+    throw new Error(`Cloudflare AI error: ${res.status} ${err}`);
+  }
+
+  const text =
+    json?.result?.response ??
+    json?.result?.output_text ??
+    json?.result?.text ??
+    json?.result?.choices?.[0]?.message?.content ??
+    json?.result?.choices?.[0]?.text ??
+    json?.choices?.[0]?.message?.content ??
+    json?.choices?.[0]?.text ??
+    null;
+
+  if (!text) {
+    throw new Error(`Cloudflare AI: unknown response shape: ${JSON.stringify(json).slice(0, 800)}`);
+  }
+  return String(text).trim();
+}
+
+function replaceBlock(readme, newBlock) {
+  const start = "<!-- DISCUSS_COACH_START -->";
+  const end = "<!-- DISCUSS_COACH_END -->";
+  const s = readme.indexOf(start);
+  const e = readme.indexOf(end);
+  if (s === -1 || e === -1 || e < s) {
+    throw new Error("README.md does not contain DISCUSS_COACH_START/END markers");
+  }
+
+  const before = readme.slice(0, s + start.length);
+  const after = readme.slice(e);
+
+  // Always overwrite content between markers (idempotent)
+  return `${before}\n${newBlock.trim()}\n\n${after}`;
+}
+
+function buildReadmeBlock({ dayJst, text, dominantWeather }) {
+  const header = `## Discussまとめ（体操のお兄さん）
+**対象日（JST）:** ${dayJst}
+`;
+  return `${header}\n${text}\n`;
+}
+
+async function main() {
+  const { dayJst, startUtc, endUtc } = getYesterdayJstRangeUtc();
+
+  // ── 天気（アメダス） ─────────────────────────
+  // NOTE: 松戸市に近いアメダス地点コードを固定で指定。
+  // もし地点を変えたい場合は、気象庁アメダス画面の amdno=xxxxx を参照。
+  // https://www.jma.go.jp/bosai/amedas/
+  const AMEDAS_POINT = process.env.AMEDAS_POINT || "44132";
+
+  const { dominantWeather, rainyHoursCount } = await getAmedasDominantWeatherForDay({
+    amedasPoint: AMEDAS_POINT,
+    dayJst,
+  });
+  const yesterdayjumpcount = await getNawatobi(dayJst);
+  console.log(`天気サマリー(AMeDAS): ${dominantWeather.icon} ${dominantWeather.label} (雨: ${rainyHoursCount}h)`);
+
+  const query = `
+query($owner:String!, $repo:String!, $after:String) {
+  repository(owner:$owner, name:$repo) {
+    discussions(first:50, after:$after, orderBy:{field:CREATED_AT, direction:DESC}) {
+      pageInfo { hasNextPage endCursor }
+      nodes { title url createdAt bodyText }
+    }
+  }
+}
+`;
+
+  const nodes = [];
+  let after = null;
+
+  while (true) {
+    const data = await ghGraphql(query, { owner: OWNER, repo: REPO, after });
+    const page = data?.data?.repository?.discussions;
+    const list = page?.nodes || [];
+
+    for (const d of list) {
+      if (d.createdAt >= startUtc && d.createdAt <= endUtc) nodes.push(d);
+    }
+
+    const oldest = list.length ? list[list.length - 1].createdAt : null;
+    const hasNext = page?.pageInfo?.hasNextPage;
+
+    if (!hasNext) break;
+    if (!oldest) break;
+    if (oldest < startUtc) break;
+
+    after = page.pageInfo.endCursor;
+  }
+
+  let finalText;
+
+  try {
+    if (nodes.length === 0) {
+      finalText = `昨日は投稿がなかったみたいだね！えらい、ちゃんと休息も取れてる！
+昨日の松戸は${dominantWeather.icon}${dominantWeather.label}だったよ。お外でもストレッチできたかな？
+今日の一言：背すじスッと、ニコッといこー！`;
+    } else {
+      const { source, usedChars } = buildPromptSource(nodes, {
+        maxPerBodyChars: 600,
+        maxTotalChars: 2500,
+      });
+
+      const system = `あなたは「体操のお兄さん」風の文章を書くプロです。
+トーンは優しめで、軽いコメディ（ツッコミ）を入れてください。
+誹謗中傷や攻撃的表現は避けてください。`;
+
+      const user = `
+昨日（JST: ${dayJst}）の松戸市の日中の天気は ${dominantWeather.label} でした。
+縄跳びは、${yesterdayjumpcount}でした。
+
+以下は昨日（JST: ${dayJst}）に投稿されたGitHub Discussionsです。本文は抜粋で、長文は省略されています。
+この内容を踏まえて、次を日本語で生成してください。
+
+要件:
+- 300文字前後（±80文字くらいはOK）
+- 適切な位置で改行(重要)
+- 「昨日のまとめ」に対する優しいお話
+- 天気にも一言触れてOK（無理に入れなくてもOK）
+- 「今日の一言」（最後に「今日の一言：...」の形式で1文）
+- 固有名詞やURLは無理に入れなくてOK（入れるなら1つまで）
+- 出力は文章だけ（箇条書きや見出しは不要）
+- コメディアンでユーモラスに
+- あなたは体操のお兄さんです！元気もりもり！
+Discussions（抜粋、合計 ${usedChars} 文字）:
+${source}
+`.trim();
+
+      const text = await cfAiChat({
+        accountId: CF_ACCOUNT_ID,
+        apiToken: CF_API_TOKEN,
+        model: CF_MODEL,
+        messages: [
+          { role: "system", content: system },
+          { role: "user", content: user },
+        ],
+       temperature:1.5,
+      });
+
+      finalText = text;
+    }
+  } catch (e) {
+    console.warn("Generation failed. Falling back to rest message.");
+    console.warn(String(e?.message || e));
+
+    finalText = `ごめんね、今日はお兄さんの声がちょっと裏返っちゃった！機械も準備体操が必要なんだ〜。
+昨日の分はアーカイブにちゃんと残してあるから安心してね。
+今日の一言：うまくいかない日こそ、ストレッチして笑って切り替えよう！`;
+  }
+
+  const newBlock = buildReadmeBlock({ dayJst, text: finalText, dominantWeather });
+
+  const readme = fs.readFileSync("README.md", "utf8");
+  const updated = replaceBlock(readme, newBlock);
+  fs.writeFileSync("README.md", updated, "utf8");
+
+  console.log(`README updated for JST ${dayJst}. discussions=${nodes.length}`);
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@oniisan/htvoffcial",
+  "version": "0.1.1",
+  "description": "GitHub automation scripts for the Taiso no Oniisan project",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "discuss-readme-coach": "./discuss_readme_coach.mjs",
+    "post-jpt-zatsudan": "./post_jpt_zatsudan.mjs",
+    "translate-discuss-coach-deepl": "./translate-discuss-coach-deepl.mjs",
+    "translates1": "./translates1.js"
+  },
+  "files": [
+    "*.mjs",
+    "*.js",
+    "!node_modules"
+  ],
+  "scripts": {
+    "test": "node --test || true"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "github-actions",
+    "automation",
+    "discussions"
+  ],
+  "license": "SSPL-1.0"
+}

package/post_jpt_zatsudan.mjs

@@ -0,0 +1,354 @@
+/*
+ Copyright (C) 2026 htvoffcial
+ SPDX-License-Identifier: SSPL-1.0
+*/
+
+import fs from "node:fs";
+import path from "node:path";
+
+const GH_TOKEN = process.env.GH_TOKEN;
+const REPOSITORY = process.env.GITHUB_REPOSITORY;
+
+if (!GH_TOKEN) throw new Error("GH_TOKEN is missing");
+if (!REPOSITORY) throw new Error("GITHUB_REPOSITORY is missing");
+
+const [owner, repo] = REPOSITORY.split("/");
+if (!owner || !repo) throw new Error(`Invalid GITHUB_REPOSITORY: ${REPOSITORY}`);
+
+const POS_TAGS = [
+  "形容動詞",
+  "接続詞",
+  "形容詞",
+  "代名詞",
+  "連体詞",
+  "感動詞",
+  "副詞",
+  "動詞",
+  "名詞",
+];
+
+// 一段動詞に見えるが五段動詞である代表的な例外
+const GODAN_EXCEPTIONS = new Set([
+  "走る", "帰る", "切る", "知る", "入る", "要る", "減る", "喋る", "限る", "握る"
+]);
+
+/**
+ * 動詞の簡易活用関数（自然な接続にするための変換）
+ */
+function conjugateVerb(verb, form) {
+  if (!verb || verb.length < 1) return verb;
+
+  // 不規則動詞の処理
+  if (verb === "する" || verb.endsWith("する")) {
+    const base = verb.slice(0, -2);
+    if (form === "連用" || form === "未然") return base + "し";
+    if (form === "て" || form === "た") return base + "した";
+    return verb;
+  }
+  if (verb === "来る" || verb === "くる") {
+    const isKanji = verb === "来る";
+    if (form === "連用") return isKanji ? "来" : "き";
+    if (form === "未然") return isKanji ? "来" : "こ";
+    if (form === "て" || form === "た") return isKanji ? "来た" : "きた";
+    return verb;
+  }
+  if (verb === "行く" && (form === "て" || form === "た")) {
+    return "行った";
+  }
+
+  const lastChar = verb.slice(-1);
+  const stem = verb.slice(0, -1);
+  const prevChar = verb.length >= 2 ? verb.slice(-2, -1) : "";
+
+  // 一段動詞か五段動詞かの判定
+  const isIchidan =
+    lastChar === "る" &&
+    /[いきしちにひみりえけせてねへめれ]/.test(prevChar) &&
+    !GODAN_EXCEPTIONS.has(verb);
+
+  if (isIchidan) {
+    if (form === "連用" || form === "未然") return stem;
+    if (form === "て" || form === "た") return stem + "た";
+    return verb;
+  }
+
+  // 五段動詞の活用
+  if (form === "連用") {
+    const map = { う: "い", く: "き", ぐ: "ぎ", す: "し", つ: "ち", ぬ: "に", ぶ: "び", む: "み", る: "り" };
+    return stem + (map[lastChar] || lastChar);
+  }
+  if (form === "未然") {
+    const map = { う: "わ", く: "か", ぐ: "が", す: "さ", つ: "た", ぬ: "な", ぶ: "ば", む: "ま", る: "ら" };
+    return stem + (map[lastChar] || lastChar);
+  }
+  if (form === "て" || form === "た") {
+    if (["う", "つ", "る"].includes(lastChar)) return stem + "った";
+    if (["む", "ぶ", "ぬ"].includes(lastChar)) return stem + "んだ";
+    if (lastChar === "く") return stem + "いた";
+    if (lastChar === "ぐ") return stem + "いだ";
+    if (lastChar === "す") return stem + "した";
+  }
+
+  return verb;
+}
+
+/**
+ * 形容動詞の語幹整形と活用
+ */
+function conjugateNaAdjective(word, nextChars) {
+  let stem = word.endsWith("だ") ? word.slice(0, -1) : word;
+
+  // 後ろが「名詞」や一般的な名詞フレーズなら「〜な」に接続
+  if (/^(\{?名詞\}?|[^\s、。！？だで])/.test(nextChars)) {
+    return `${stem}な`;
+  }
+  // 後ろが「です」「でした」なら語幹のまま
+  if (/^(です|でした)/.test(nextChars)) {
+    return stem;
+  }
+  // 文末などで直接終わる場合
+  if (/^[。！？\s]*$/.test(nextChars)) {
+    return `${stem}だ`;
+  }
+  return stem;
+}
+
+function pickRandomUnique(list, usedSet) {
+  if (!Array.isArray(list) || list.length === 0) return "";
+  const available = list.filter((w) => !usedSet.has(w));
+  const pool = available.length > 0 ? available : list;
+  const index = Math.floor(Math.random() * pool.length);
+  const picked = pool[index] || "";
+  usedSet.add(picked);
+  return picked;
+}
+
+function loadTemplates(baseDir) {
+  const filePath = path.join(baseDir, ".github", "assets", "jpt_goj.csv");
+  const raw = fs.readFileSync(filePath, "utf8");
+  return raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith("#"));
+}
+
+function loadWordsByPos(baseDir) {
+  const filePath = path.join(baseDir, ".github", "assets", "jpt_cps.csv");
+  const raw = fs.readFileSync(filePath, "utf8");
+  const lines = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  const map = new Map();
+
+  for (const line of lines.slice(1)) {
+    const commaIndex = line.lastIndexOf(",");
+    if (commaIndex <= 0) continue;
+
+    const word = line.slice(0, commaIndex).trim();
+    const pos = line.slice(commaIndex + 1).trim();
+
+    if (!word || !pos) continue;
+
+    if (!map.has(pos)) map.set(pos, []);
+    map.get(pos).push(word);
+  }
+
+  return map;
+}
+
+/**
+ * テンプレート置換（シングルパス正規表現＆コンテキストに応じた自動活用）
+ */
+function fillTemplate(template, wordsByPos) {
+  const usedWords = new Set();
+
+  // {名詞} または 名詞 のどちらの表記にも対応
+  const pattern = new RegExp(
+    `\\{?(${POS_TAGS.join("|")})(?::([a-zA-Z0-9_]+))?\\}?`,
+    "g"
+  );
+
+  // シングルパスで置換し、多重置換バグを防止
+  let result = template.replace(pattern, (match, pos, explicitForm, offset, fullStr) => {
+    const words = wordsByPos.get(pos) || [];
+    let word = pickRandomUnique(words, usedWords);
+    if (!word) return match;
+
+    const remaining = fullStr.slice(offset + match.length);
+
+    // 1. 動詞の自動活用
+    if (pos === "動詞") {
+      if (explicitForm) {
+        word = conjugateVerb(word, explicitForm);
+      } else if (/^(ます|ました|ません|たい|つつ|ながら|そう)/.test(remaining)) {
+        word = conjugateVerb(word, "連用");
+      } else if (/^(て|た|だ)/.test(remaining)) {
+        word = conjugateVerb(word, "て");
+      } else if (/^(ない|なかった|れる|られる|せる|させる)/.test(remaining)) {
+        word = conjugateVerb(word, "未然");
+      }
+    }
+
+    // 2. 形容動詞の自動調整
+    if (pos === "形容動詞") {
+      word = conjugateNaAdjective(word, remaining);
+    }
+
+    return word;
+  });
+
+  // 不自然な助詞の重なりや空白のクリーンアップ
+  result = result
+    .replace(/[ \t]+/g, " ")
+    .replace(/をを/g, "を")
+    .replace(/がが/g, "が")
+    .replace(/はは/g, "は")
+    .replace(/、、+/g, "、")
+    .trim();
+
+  return result;
+}
+
+/**
+ * より人間らしく自然なディスカッションタイトルの生成
+ */
+function buildTitle(sentence) {
+  const clean = sentence.trim().replace(/\s+/g, " ");
+
+  // 35文字以下なら、そのまま自然なタイトルとして採用
+  if (clean.length <= 35) {
+    return clean;
+  }
+
+  // 最初の1文（「。」や「！？\n」まで）を取得
+  const firstSentence = clean.split(/[。！？!?\n]/)[0]?.trim();
+  if (firstSentence && firstSentence.length >= 5 && firstSentence.length <= 40) {
+    // 疑問文で終わっている場合はそのまま活用
+    if (clean.includes("？") || clean.includes("?")) {
+      return `${firstSentence}？`;
+    }
+    return `${firstSentence}`;
+  }
+
+  // 長い場合のフォールバック（不自然に文字を切らず、語尾に…を付与）
+  return `${clean.slice(0, 32)}…`;
+}
+
+async function ghGraphql(query, variables) {
+  const res = await fetch("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: `bearer ${GH_TOKEN}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+
+  const json = await res.json().catch(() => null);
+
+  if (!res.ok || json?.errors?.length) {
+    throw new Error(`GraphQL failed: ${res.status} ${JSON.stringify(json)}`);
+  }
+
+  return json.data;
+}
+
+async function resolveCategoryAndRepoId() {
+  const query = `
+    query($owner: String!, $repo: String!) {
+      repository(owner: $owner, name: $repo) {
+        id
+        discussionCategories(first: 50) {
+          nodes {
+            id
+            name
+            emoji
+          }
+        }
+      }
+    }
+  `;
+
+  const data = await ghGraphql(query, { owner, repo });
+  const repository = data?.repository;
+
+  if (!repository?.id) {
+    throw new Error("repository.id was not found");
+  }
+
+  const categories = repository.discussionCategories?.nodes || [];
+  const zatsudan = categories.find((c) => String(c?.name || "").includes("雑談"));
+
+  if (!zatsudan?.id) {
+    throw new Error("Discussion category '雑談' was not found");
+  }
+
+  return {
+    repositoryId: repository.id,
+    categoryId: zatsudan.id,
+  };
+}
+
+async function createDiscussion({ repositoryId, categoryId, title, body }) {
+  const mutation = `
+    mutation($repositoryId: ID!, $categoryId: ID!, $title: String!, $body: String!) {
+      createDiscussion(input: {
+        repositoryId: $repositoryId,
+        categoryId: $categoryId,
+        title: $title,
+        body: $body
+      }) {
+        discussion {
+          id
+          url
+          title
+        }
+      }
+    }
+  `;
+
+  const data = await ghGraphql(mutation, {
+    repositoryId,
+    categoryId,
+    title,
+    body,
+  });
+
+  return data?.createDiscussion?.discussion;
+}
+
+async function main() {
+  const baseDir = process.cwd();
+
+  const templates = loadTemplates(baseDir);
+  if (templates.length === 0) throw new Error("No templates found in jpt_goj.csv");
+
+  const wordsByPos = loadWordsByPos(baseDir);
+  const template = pickRandomUnique(templates, new Set());
+  const sentence = fillTemplate(template, wordsByPos);
+  const title = buildTitle(sentence);
+
+  const { repositoryId, categoryId } = await resolveCategoryAndRepoId();
+
+  const discussion = await createDiscussion({
+    repositoryId,
+    categoryId,
+    title,
+    body: sentence,
+  });
+
+  if (!discussion?.url) {
+    throw new Error("Failed to create discussion");
+  }
+
+  console.log(`Created discussion: ${discussion.url}`);
+  console.log(`Title: ${discussion.title}`);
+  console.log(`Body: ${sentence}`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/translate-discuss-coach-deepl.mjs

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const START = "<!-- DISCUSS_COACH_START -->";
+const END = "<!-- DISCUSS_COACH_END -->";
+
+function extractBetween(text) {
+  const startIdx = text.indexOf(START);
+  const endIdx = text.indexOf(END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return null;
+  return text.slice(startIdx + START.length, endIdx).trim();
+}
+
+function extractSourceDateJST(text) {
+  // README中にある: **対象日（JST）:** 2026-04-17
+  const m = text.match(/\*\*対象日（JST）:\*\*\s*([0-9]{4}-[0-9]{2}-[0-9]{2})/);
+  return m?.[1] ?? "";
+}
+
+async function deeplTranslate(text, { apiKey, baseUrl }) {
+  if (!apiKey) throw new Error("Missing DEEPL_API_KEY secret");
+
+  // baseUrlは secrets に入れるのが安全（Free/Pro切替）
+  const endpoint = (baseUrl || "https://api-free.deepl.com").replace(/\/$/, "") + "/v2/translate";
+
+  const params = new URLSearchParams();
+  params.append("text", text);
+  params.append("target_lang", "EN"); // 例: "EN" or "EN-US" or "EN-GB"
+  // params.append("source_lang", "JA"); // 必要なら固定
+  params.append("preserve_formatting", "1");
+
+  // DeepL API: Authorization: DeepL-Auth-Key xxx
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `DeepL-Auth-Key ${apiKey}`,
+    },
+    body: params.toString(),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`DeepL API error: ${res.status} ${body}`);
+  }
+
+  const data = await res.json();
+  const translated = data?.translations?.[0]?.text;
+  if (!translated) throw new Error("DeepL returned no translation text");
+  return String(translated).trim();
+}
+
+async function main() {
+  const readmePath = path.resolve("README.md");
+  const src = fs.readFileSync(readmePath, "utf8");
+
+  const inner = extractBetween(src);
+  if (!inner) throw new Error("Could not find DISCUSS_COACH markers in README.md");
+
+  const sourceDate = extractSourceDateJST(inner);
+
+  const english = await deeplTranslate(inner, {
+    apiKey: process.env.DEEPL_API_KEY,
+    baseUrl: process.env.DEEPL_API_BASE_URL,
+  });
+
+  const outDir = path.resolve(".github/English");
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const outPath = path.join(outDir, "README.md");
+
+
+
+  const out = `
+${english}
+${END}
+`;
+
+  fs.writeFileSync(outPath, out, "utf8");
+  console.log(`Wrote ${outPath}`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/translates1.js

@@ -0,0 +1,336 @@
+(() => {
+  const STORAGE_KEY = "certinaly_lang_barrier_v2";
+
+  // === 170+ Countries (ISO 3166-1 alpha-2) ===
+  const ALL_COUNTRIES = [
+    "AF","AL","DZ","AD","AO","AR","AM","AU","AT","AZ","BS","BH","BD","BB","BY","BE","BZ","BJ","BT","BO","BA","BW","BR","BN","BG","BF","BI","KH","CM","CA",
+    "CV","CF","TD","CL","CN","CO","KM","CG","CD","CR","CI","HR","CU","CY","CZ","DK","DJ","DM","DO","EC","EG","SV","GQ","ER","EE","ET","FJ","FI","FR",
+    "GA","GM","GE","DE","GH","GR","GD","GT","GN","GW","GY","HT","HN","HU","IS","IN","ID","IR","IQ","IE","IL","IT","JM","JP","JO","KZ","KE","KI","KP","KR",
+    "KW","KG","LA","LV","LB","LS","LR","LY","LI","LT","LU","MG","MW","MY","MV","ML","MT","MR","MU","MX","MD","MC","MN","ME","MA","MZ","MM","NA","NR","NP",
+    "NL","NZ","NI","NE","NG","NO","OM","PK","PA","PG","PY","PE","PH","PL","PT","QA","RO","RU","RW","SA","SN","RS","SC","SL","SG","SK","SI","SB","SO",
+    "ZA","ES","LK","SD","SR","SZ","SE","CH","SY","TW","TJ","TZ","TH","TL","TG","TO","TT","TN","TR","TM","UG","UA","AE","GB","US","UY","UZ","VE","VN",
+    "YE","ZM","ZW"
+  ];
+
+  // === Country → Language overrides ===
+  const COUNTRY_GROUPS = {
+    ja: ["JP"],
+    zh: ["CN","TW","HK","MO"],
+    ko: ["KR","KP"],
+    ru: ["RU","BY","KZ","KG","TJ","UZ"],
+    uk: ["UA"],
+    ar: ["SA","AE","QA","BH","KW","OM","YE","EG","SD","LY","TN","DZ","MA","JO","LB","SY","IQ","PS","MR","SO"],
+    fa: ["IR","AF"],
+    he: ["IL"],
+    el: ["GR","CY"],
+    tr: ["TR","AZ","TM"],
+    hi: ["IN","NP"],
+    bn: ["BD"],
+    ur: ["PK"],
+    th: ["TH"],
+    vi: ["VN"],
+    id: ["ID"],
+    ms: ["MY","BN","SG"],
+    de: ["DE","AT","CH","LI","LU"],
+    fr: ["FR","BE","CI","SN","ML","NE","BF","BJ","TG","CM","GA","GN","CG","CD","MG","TD","DJ","KM","SC"],
+    es: ["ES","MX","AR","CO","CL","PE","VE","EC","BO","UY","PY","CR","GT","SV","HN","NI","PA","DO","CU","GQ"],
+    pt: ["PT","BR","AO","MZ","CV","GW","ST","TL"],
+    it: ["IT","SM","VA"],
+    nl: ["NL","SR"],
+    sv: ["SE"],
+    no: ["NO"],
+    da: ["DK"],
+    fi: ["FI"],
+    pl: ["PL"],
+    cs: ["CZ"],
+    sk: ["SK"],
+    hu: ["HU"],
+    ro: ["RO","MD"],
+    bg: ["BG"]
+  };
+
+  // === Build Country→Lang map (default to latin) ===
+  const COUNTRY_LANG = Object.fromEntries(ALL_COUNTRIES.map(c => [c, "latin"]));
+  Object.entries(COUNTRY_GROUPS).forEach(([lang, codes]) => {
+    codes.forEach(code => COUNTRY_LANG[code] = lang);
+  });
+
+  // === Character sets ===
+  const latinChars =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const cyrillicChars =
+    "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ" +
+    "абвгдеёжзийклмнопрстуфхцчшщъыьэюя";
+  const arabicChars = Array.from({ length: 256 }, (_, i) => String.fromCharCode(0x0600 + i)).join("");
+  const hanChars = Array.from({ length: 1500 }, (_, i) => String.fromCharCode(0x4E00 + i)).join("");
+  const devanagariChars = Array.from({ length: 128 }, (_, i) => String.fromCharCode(0x0900 + i)).join("");
+  const thaiChars = Array.from({ length: 128 }, (_, i) => String.fromCharCode(0x0E00 + i)).join("");
+  const hebrewChars = Array.from({ length: 96 }, (_, i) => String.fromCharCode(0x0590 + i)).join("");
+  const greekChars = Array.from({ length: 96 }, (_, i) => String.fromCharCode(0x0370 + i)).join("");
+  const hangulChars = Array.from({ length: 512 }, (_, i) => String.fromCharCode(0xAC00 + i)).join("");
+  const englishVowelPool = "eeeeaaaaiiiooouuuy";
+  const englishConsonantPool = "ttttrrrrssssnnnlllccchhddmmffggppbbvvkkjxxqqzz";
+  const englishVowels = "aeiouy";
+
+  // === Language configs ===
+  const LANG_META = {
+    ja: { label: "日本語", chars: null, font: "sans-serif", dir: "ltr" },
+    en: { label: "English", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    latin: { label: "Latin", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    es: { label: "Español", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    fr: { label: "Français", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    pt: { label: "Português", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    de: { label: "Deutsch", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    it: { label: "Italiano", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    nl: { label: "Nederlands", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    sv: { label: "Svenska", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    no: { label: "Norsk", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    da: { label: "Dansk", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    fi: { label: "Suomi", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    pl: { label: "Polski", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    cs: { label: "Čeština", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    sk: { label: "Slovenčina", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    hu: { label: "Magyar", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    ro: { label: "Română", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    bg: { label: "Български", chars: cyrillicChars, font: "'Ruslan Display', cursive", dir: "ltr" },
+    ru: { label: "Русский", chars: cyrillicChars, font: "'Ruslan Display', cursive", dir: "ltr" },
+    uk: { label: "Українська", chars: cyrillicChars, font: "'Ruslan Display', cursive", dir: "ltr" },
+    ar: { label: "العربية", chars: arabicChars, font: "'Amiri', serif", dir: "rtl" },
+    fa: { label: "فارسی", chars: arabicChars, font: "'Amiri', serif", dir: "rtl" },
+    he: { label: "עברית", chars: hebrewChars, font: "'Noto Serif Hebrew', serif", dir: "rtl" },
+    el: { label: "Ελληνικά", chars: greekChars, font: "'Noto Serif Greek', serif", dir: "ltr" },
+    zh: { label: "中文", chars: hanChars, font: "'Zhi Mang Xing', cursive", dir: "ltr" },
+    ko: { label: "한국어", chars: hangulChars, font: "'Noto Sans KR', sans-serif", dir: "ltr" },
+    hi: { label: "हिन्दी", chars: devanagariChars, font: "'Noto Sans Devanagari', sans-serif", dir: "ltr" },
+    bn: { label: "বাংলা", chars: devanagariChars, font: "'Noto Sans Devanagari', sans-serif", dir: "ltr" },
+    ur: { label: "اردو", chars: arabicChars, font: "'Amiri', serif", dir: "rtl" },
+    th: { label: "ไทย", chars: thaiChars, font: "'Noto Sans Thai', sans-serif", dir: "ltr" },
+    vi: { label: "Tiếng Việt", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    id: { label: "Bahasa Indonesia", chars: latinChars, font: "sans-serif", dir: "ltr" },
+    ms: { label: "Bahasa Melayu", chars: latinChars, font: "sans-serif", dir: "ltr" }
+  };
+
+  const LANG_ORDER = [
+    "ja","en","latin","es","fr","pt","de","it","nl","sv","no","da","fi","pl","cs","sk","hu","ro","bg",
+    "ru","uk","ar","fa","he","el","zh","ko","hi","bn","ur","th","vi","id","ms"
+  ];
+
+  // === Load fonts (once) ===
+  const fontsHref =
+    "https://fonts.googleapis.com/css2" +
+    "?family=Amiri" +
+    "&family=Ruslan+Display" +
+    "&family=Zhi+Mang+Xing" +
+    "&family=Noto+Sans+KR" +
+    "&family=Noto+Sans+Thai" +
+    "&family=Noto+Sans+Devanagari" +
+    "&family=Noto+Serif+Hebrew" +
+    "&family=Noto+Serif+Greek" +
+    "&display=swap";
+  if (!document.querySelector(`link[href="${fontsHref}"]`)) {
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = fontsHref;
+    document.head.appendChild(link);
+  }
+
+  // === Text node collection ===
+  const EXCLUDE_TAGS = new Set(["SCRIPT","STYLE","TEXTAREA","INPUT","OPTION","SELECT","NOSCRIPT"]);
+  const originalMap = new WeakMap();
+  const textNodes = new Set();
+  let currentLang = "ja";
+
+  function isSkippable(node) {
+    if (!node || !node.parentElement) return true;
+    const tag = node.parentElement.tagName;
+    if (EXCLUDE_TAGS.has(tag)) return true;
+    if (node.parentElement.closest("[contenteditable='true']")) return true;
+    return false;
+  }
+
+  function collectTextNodes(root) {
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+      acceptNode(node) {
+        if (isSkippable(node)) return NodeFilter.FILTER_REJECT;
+        if (!node.nodeValue || !node.nodeValue.trim()) return NodeFilter.FILTER_REJECT;
+        return NodeFilter.FILTER_ACCEPT;
+      }
+    });
+    while (walker.nextNode()) {
+      const node = walker.currentNode;
+      if (!originalMap.has(node)) originalMap.set(node, node.nodeValue);
+      textNodes.add(node);
+    }
+  }
+
+  const baseIndexCache = new Map();
+  function hashString(value) {
+    let hash = 0;
+    for (let i = 0; i < value.length; i += 1) {
+      hash = ((hash << 5) - hash) + value.charCodeAt(i);
+      hash |= 0;
+    }
+    return hash;
+  }
+
+  function mapWithJitter(charSet, baseKey, jitterSeed, jitterRange, lastMapped) {
+    let baseIndex = baseIndexCache.get(baseKey);
+    if (baseIndex === undefined) {
+      baseIndex = Math.abs(hashString(baseKey)) % charSet.length;
+      baseIndexCache.set(baseKey, baseIndex);
+    }
+
+    const jitter = Math.abs(hashString(jitterSeed)) % jitterRange;
+    let mappedIndex = (baseIndex + jitter) % charSet.length;
+    let mapped = charSet[mappedIndex];
+
+    if (mapped === lastMapped && charSet.length > 1) {
+      mappedIndex = (mappedIndex + 1) % charSet.length;
+      mapped = charSet[mappedIndex];
+    }
+
+    return mapped;
+  }
+
+  function scramble(text, charSet, langKey) {
+    const jitterRange = Math.min(128, Math.max(8, Math.floor(charSet.length / 4)));
+    let lastMapped = "";
+    let wordIndex = 0;
+    let output = "";
+
+    for (let index = 0; index < text.length; index += 1) {
+      const char = text[index];
+      if (/\s/.test(char)) {
+        output += char;
+        wordIndex += 1;
+        lastMapped = "";
+        continue;
+      }
+      if (/([.,!?;:！？。、「」()0-9])/.test(char)) {
+        output += char;
+        continue;
+      }
+
+      const baseKey = `${langKey}|${char}|${wordIndex}`;
+      const jitterSeed = `${baseKey}|${index}`;
+      let activeCharSet = charSet;
+      let mapped;
+
+      if (langKey === "en") {
+        const lower = char.toLowerCase();
+        const isVowel = englishVowels.includes(lower);
+        activeCharSet = isVowel ? englishVowelPool : englishConsonantPool;
+        mapped = mapWithJitter(activeCharSet, baseKey, jitterSeed, jitterRange, lastMapped);
+        if (char !== lower) mapped = mapped.toUpperCase();
+      } else {
+        mapped = mapWithJitter(activeCharSet, baseKey, jitterSeed, jitterRange, lastMapped);
+      }
+
+      lastMapped = mapped;
+      output += mapped;
+    }
+
+    return output;
+  }
+
+  // === Apply language ===
+  function applyLanguage(lang) {
+    const config = LANG_META[lang] || LANG_META.ja;
+    currentLang = lang;
+
+    document.body.style.fontFamily = config.font;
+    document.body.style.direction = config.dir;
+
+    textNodes.forEach(node => {
+      const original = originalMap.get(node) || node.nodeValue;
+      if (lang === "ja" || !config.chars) {
+        node.nodeValue = original;
+      } else {
+        node.nodeValue = scramble(original, config.chars, lang);
+      }
+    });
+
+    localStorage.setItem(STORAGE_KEY, lang);
+  }
+
+  // === Language detection ===
+  function detectLang() {
+    const saved = localStorage.getItem(STORAGE_KEY);
+    if (saved) return saved;
+
+    const raw = (navigator.language || navigator.userLanguage || "ja").toLowerCase();
+    const parts = raw.split(/[-_]/);
+    const lang = parts[0];
+    const country = (parts[1] || "").toUpperCase();
+
+    if (country && COUNTRY_LANG[country]) return COUNTRY_LANG[country];
+    if (LANG_META[lang]) return lang;
+    return "ja";
+  }
+
+  // === UI ===
+  function buildSelector() {
+    const container = document.createElement("div");
+    container.id = "barrier-container";
+    container.style.cssText = `
+      display:flex;
+      background: gainsboro; padding: 12px;
+      border: 2px solid #333;
+      width:fit-content;
+ justify-content: center;
+  align-items: center;
+      z-index: 100000; font-family: sans-serif;
+    `;
+
+    const label = document.createElement("label");
+    label.htmlFor = "lang-select";
+    label.textContent = "Language: ";
+    container.appendChild(label);
+
+    const select = document.createElement("select");
+    select.id = "lang-select";
+    LANG_ORDER.forEach(key => {
+      if (!LANG_META[key]) return;
+      const opt = document.createElement("option");
+      opt.value = key;
+      opt.textContent = LANG_META[key].label;
+      select.appendChild(opt);
+    });
+    select.addEventListener("change", e => applyLanguage(e.target.value));
+
+    container.appendChild(select);
+    document.body.appendChild(container);
+  }
+
+  // === Init ===
+  function init() {
+    collectTextNodes(document.body);
+    buildSelector();
+
+    const initial = detectLang();
+    const select = document.getElementById("lang-select");
+    if (select) select.value = initial;
+    applyLanguage(initial);
+
+    // Observe dynamic content
+    const observer = new MutationObserver(mutations => {
+      mutations.forEach(m => {
+        m.addedNodes.forEach(node => {
+          if (node.nodeType === 1 || node.nodeType === 11) {
+            collectTextNodes(node);
+          } else if (node.nodeType === 3) {
+            collectTextNodes(node.parentNode || document.body);
+          }
+        });
+      });
+      if (currentLang !== "ja") applyLanguage(currentLang);
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", init);
+  } else {
+    init();
+  }
+})();