Language

Author: Clawb1t

check.js

@@ -0,0 +1,4 @@
+const m = require('./i18n/locales/manifest.json');
+const v = m['stats.engagementTotalsBody'];
+console.log('has real newline char:', v.includes(String.fromCharCode(10)));
+console.log('length', v.length);

i18n/locales/manifest.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "generatedAt": "2026-09-14T19:16:38.387Z",
+  "generatedAt": "2026-09-15T08:36:20.007Z",
   "templatePath": "config/default.server.yaml",
   "schemaPath": "schema/guild-config.schema.json",
   "categories": [

schema/guild-config.meta.json

@@ -75,9 +75,40 @@ function readStringLiteral(src: string, i: number): { raw: string; next: number
   return null;
 }
 
+/** Standard JS escape sequences a string/template literal can contain. `${...}` inside a
+ *  template literal is deliberately left as literal text (see header) — only backslash escapes
+ *  are resolved here. Unrecognized escapes (e.g. `ሴ`, `\x41`) are left as-is; none of our
+ *  translation strings use them. */
+const ESCAPES: Record<string, string> = {
+  n: "\n",
+  t: "\t",
+  r: "\r",
+  "\\": "\\",
+  "'": "'",
+  '"': '"',
+  "`": "`",
+  b: "\b",
+  f: "\f",
+  v: "\v",
+  "0": "\0",
+};
+
 function literalValue(raw: string): string {
-  // Strip the surrounding quote/backtick; leave escapes and ${...} as-is (best effort — see header).
-  return raw.slice(1, -1);
+  // Strip the surrounding quote/backtick, then resolve backslash escapes so the manifest holds
+  // the actual runtime string (a literal `\n` in source must become a real newline here) — not
+  // the raw source text, which is what a translator/machine-translation call actually needs.
+  const inner = raw.slice(1, -1);
+  let out = "";
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === "\\" && i + 1 < inner.length) {
+      const next = inner[i + 1]!;
+      out += next in ESCAPES ? ESCAPES[next] : `\\${next}`;
+      i += 1;
+    } else {
+      out += inner[i];
+    }
+  }
+  return out;
 }
 
 const CALL_PATTERN = /(?<![\w$])t\(/g;

scripts/extractI18nKeys.ts

@@ -603,7 +603,7 @@ export function startDashboardBridge(client: Client, configManager: ConfigManage
 
         if (req.method === "GET" && url.pathname === "/bridge/languages") {
           const { listLanguagesForWeb } = await import("./webLanguage.js");
-          sendJson(res, 200, { ok: true, languages: listLanguagesForWeb() });
+          sendJson(res, 200, { ok: true, languages: await listLanguagesForWeb() });
           return;
         }
 

src/bridge/dashboardBridge.ts

@@ -16,10 +16,10 @@ import {
   type LanguageRecord,
 } from "../i18n/index.js";
 
-export type LanguageOptionForWeb = { id: string; label: string };
+export type LanguageOptionForWeb = { id: string; label: string; flag: string };
 
 export function listLanguagesForWeb(): Promise<LanguageOptionForWeb[]> {
-  return listEnabledLanguages().then((langs) => langs.map((l) => ({ id: l.code, label: l.name })));
+  return listEnabledLanguages().then((langs) => langs.map((l) => ({ id: l.code, label: l.name, flag: l.flag })));
 }
 
 export async function getLanguageForWeb(discordId: string): Promise<{ locale: string }> {

src/bridge/webLanguage.ts

@@ -61,42 +61,52 @@ export function startBulkTranslate(locale: string): BulkTranslateStatus {
   return status;
 }
 
-const PLACEHOLDER_PATTERN = /\{(\w+)\}/g;
+/** Matches everything that must survive machine translation byte-for-byte: a `{varName}`
+ *  placeholder, a literal backtick (Discord code-span markdown, e.g. `` `{count}` `` — left
+ *  alone, Google Translate tends to swap straight backticks/quotes for locale-specific curly
+ *  quote characters, e.g. „79") , or a real newline (multi-line fields like the edits/deletes/
+ *  reactions/attachments summary — translating the whole blob as one string is fine, but a
+ *  newline getting reflowed or dropped isn't). */
+const GUARDED_PATTERN = /\{(\w+)\}|`|\n/g;
 /** Meaningless token (not a real word in any language, so Google Translate has nothing to
- *  translate) standing in for each `{varName}` while the surrounding text gets translated. */
+ *  translate) standing in for each guarded piece while the surrounding text gets translated. */
 const guardToken = (index: number) => `qxkz${index}qxkz`;
 const GUARD_PATTERN = /qxkz\s*(\d+)\s*qxkz/gi;
 
-/** Swaps every `{varName}` for a guard token so machine translation can't mangle it, then swaps
- *  the guard tokens back to their original `{varName}` placeholders afterward — translators
+type GuardedPiece = { varName: string } | "backtick" | "newline";
+
+/** Swaps every placeholder/backtick/newline for a guard token so machine translation can't
+ *  mangle them, then swaps the guard tokens back to the original text afterward — translators
  *  regularly reorder/adjust spacing around words but leave a meaningless alphanumeric token
- *  alone, which plain `{varName}` (real words, real brackets) doesn't survive nearly as well. */
-function guardPlaceholders(text: string): { guarded: string; names: string[] } {
-  const names: string[] = [];
-  const guarded = text.replace(PLACEHOLDER_PATTERN, (_match, name: string) => {
-    const token = guardToken(names.length);
-    names.push(name);
+ *  alone, which real punctuation/whitespace doesn't survive nearly as well. */
+function guardText(text: string): { guarded: string; pieces: GuardedPiece[] } {
+  const pieces: GuardedPiece[] = [];
+  const guarded = text.replace(GUARDED_PATTERN, (match, name: string | undefined) => {
+    const token = guardToken(pieces.length);
+    pieces.push(name !== undefined ? { varName: name } : match === "`" ? "backtick" : "newline");
     return token;
   });
-  return { guarded, names };
+  return { guarded, pieces };
 }
 
-function restorePlaceholders(text: string, names: string[]): string {
+function restoreGuardedText(text: string, pieces: GuardedPiece[]): string {
   return text.replace(GUARD_PATTERN, (match, indexRaw: string) => {
-    const index = Number(indexRaw);
-    const name = names[index];
-    return name !== undefined ? `{${name}}` : match;
+    const piece = pieces[Number(indexRaw)];
+    if (piece === undefined) return match;
+    if (piece === "backtick") return "`";
+    if (piece === "newline") return "\n";
+    return `{${piece.varName}}`;
   });
 }
 
 async function translateOne(locale: string, englishText: string): Promise<string | null> {
   const trimmed = englishText.trim();
   if (!trimmed) return "";
-  const { guarded, names } = guardPlaceholders(trimmed);
+  const { guarded, pieces } = guardText(trimmed);
   try {
     const { translateText } = await import("../plugins/translation/functions/translate.js");
     const result = await translateText(guarded, locale, "en");
-    return names.length ? restorePlaceholders(result.text, names) : result.text;
+    return pieces.length ? restoreGuardedText(result.text, pieces) : result.text;
   } catch (error) {
     log.warn(`[i18n] Machine translation failed for "${locale}":`, error);
     return null;

src/i18n/bulkTranslate.ts

@@ -13,18 +13,21 @@ import {
   normalizeAutothreadRules,
 } from "./rules.js";
 import { shouldTriggerAutothreadByCadence } from "./state.js";
+import { translatorFor } from "../../../i18n/index.js";
 
 const ALL_CHANNELS = "*";
 const THREAD_NAME_MAX = 100;
 
-function threadNameFromRule(message: Message, nameTemplate: string): string {
+async function threadNameFromRule(message: Message, nameTemplate: string): Promise<string> {
   const rendered = renderTemplate(nameTemplate, {
     guild: message.guild,
     channel: message.channel as TextChannel,
     user: message.author,
     member: message.member as GuildMember | null,
   }).slice(0, THREAD_NAME_MAX);
-  return rendered.length > 0 ? rendered : "Thread";
+  if (rendered.length > 0) return rendered;
+  const { t } = await translatorFor(message.author.id);
+  return t("autothreads.defaultThreadName", "Thread");
 }
 
 export async function handleAutothreadMessage(message: Message): Promise<void> {
@@ -79,7 +82,7 @@ export async function handleAutothreadMessage(message: Message): Promise<void> {
 
     const thread = await message
       .startThread({
-        name: threadNameFromRule(message, rule.thread_name),
+        name: await threadNameFromRule(message, rule.thread_name),
         autoArchiveDuration: rule.auto_archive_minutes as ThreadAutoArchiveDuration,
         ...(rule.thread_slowmode_seconds ? { rateLimitPerUser: rule.thread_slowmode_seconds } : {}),
       })