Skip to content

armgit / Orkas

Public Imported from GitHub
0

Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.

24.2 KB
Raw Blame
import * as fs from 'node:fs';
import * as path from 'node:path';
import vm from 'node:vm';

import * as ts from 'typescript';
import { describe, expect, it, vi } from 'vitest';
import { LOCALES as MAIN_LOCALES } from '../../src/main/i18n';

const rendererRoot = path.resolve(__dirname, '../../src/renderer');
const i18nSource = fs.readFileSync(
  path.join(rendererRoot, 'modules', 'i18n.js'),
  'utf8',
);
const LANGS = MAIN_LOCALES.map((locale) => locale.code);

type Deferred<T> = {
  promise: Promise<T>;
  resolve: (value: T) => void;
};

function deferred<T>(): Deferred<T> {
  let resolvePromise!: (value: T) => void;
  const promise = new Promise<T>((resolveValue) => {
    resolvePromise = resolveValue;
  });
  return { promise, resolve: resolvePromise };
}

function domElement(attributes: Record<string, string>, textContent: string) {
  return {
    attributes: { ...attributes },
    textContent,
    getAttribute(name: string) {
      return this.attributes[name] ?? null;
    },
    setAttribute(name: string, value: string) {
      this.attributes[name] = value;
    },
  };
}

function loadI18n(options: {
  boot?: unknown;
  getLanguage?: () => Promise<unknown>;
  getLocales?: () => Promise<unknown>;
  setLanguage?: (lang: string) => Promise<unknown>;
  textElements?: any[];
  placeholderElements?: any[];
  titleElements?: any[];
  ariaLabelElements?: any[];
} = {}) {
  const textElements = options.textElements || [];
  const placeholderElements = options.placeholderElements || [];
  const titleElements = options.titleElements || [];
  const ariaLabelElements = options.ariaLabelElements || [];
  const htmlAttributes: Record<string, string> = {};
  const events: Array<{ type: string; detail: unknown }> = [];
  const warnings: unknown[][] = [];
  class FakeCustomEvent {
    type: string;
    detail: unknown;
    constructor(type: string, init?: { detail?: unknown }) {
      this.type = type;
      this.detail = init?.detail;
    }
  }
  const document = {
    documentElement: {
      setAttribute(name: string, value: string) {
        htmlAttributes[name] = value;
      },
    },
    querySelectorAll(selector: string) {
      if (selector === '[data-i18n]') return textElements;
      if (selector === '[data-i18n-placeholder]') return placeholderElements;
      if (selector === '[data-i18n-title]') return titleElements;
      if (selector === '[data-i18n-aria-label]') return ariaLabelElements;
      return [];
    },
  };
  const windowObject: Record<string, any> = {
    __orkasI18nBoot: options.boot ?? null,
    orkas: {
      getLanguage: options.getLanguage || (async () => ({ ok: true, language: 'en' })),
      getLocales: options.getLocales || (async () => ({ ok: true, tables: {} })),
      setLanguage: options.setLanguage || (async (lang: string) => ({ ok: true, language: lang })),
    },
    dispatchEvent(event: FakeCustomEvent) {
      events.push({ type: event.type, detail: event.detail });
    },
  };
  const sandbox: Record<string, any> = {
    window: windowObject,
    document,
    CustomEvent: FakeCustomEvent,
    createLogger: () => ({
      warn: (...args: unknown[]) => warnings.push(args),
    }),
    Set,
    Map,
    Object,
    Array,
    String,
    Number,
    Promise,
    Math,
  };
  vm.runInNewContext(i18nSource, sandbox, { filename: 'i18n.js' });
  return { sandbox, htmlAttributes, events, warnings };
}

function localeTables(side: 'main' | 'renderer') {
  return Object.fromEntries(LANGS.map((lang) => [
    lang,
    JSON.parse(fs.readFileSync(
      path.resolve(rendererRoot, '..', side, 'locales', `${lang}.json`),
      'utf8',
    )),
  ])) as Record<typeof LANGS[number], Record<string, string>>;
}

function placeholders(value: string): string[] {
  return [...value.matchAll(/\{(\w+)\}/g)].map((match) => match[1]).sort();
}

function translationKeyChoices(node: ts.Expression): string[] {
  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
    return [node.text];
  }
  if (ts.isParenthesizedExpression(node)) return translationKeyChoices(node.expression);
  if (ts.isConditionalExpression(node)) {
    return [
      ...translationKeyChoices(node.whenTrue),
      ...translationKeyChoices(node.whenFalse),
    ];
  }
  return [];
}

function literalTranslationKeys(file: string): string[] {
  const source = fs.readFileSync(file, 'utf8');
  const sourceFile = ts.createSourceFile(
    file,
    source,
    ts.ScriptTarget.Latest,
    true,
    file.endsWith('.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS,
  );
  const keys: string[] = [];
  const visit = (node: ts.Node) => {
    if (
      ts.isCallExpression(node)
      && ts.isIdentifier(node.expression)
      && ['t', '_t'].includes(node.expression.text)
      && node.arguments.length > 0
    ) {
      keys.push(...translationKeyChoices(node.arguments[0]));
    }
    ts.forEachChild(node, visit);
  };
  visit(sourceFile);
  return keys;
}

function sourceFiles(root: string): string[] {
  return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
    const absolute = path.join(root, entry.name);
    if (entry.isDirectory()) return sourceFiles(absolute);
    return /\.(?:ts|js)$/.test(entry.name) ? [absolute] : [];
  });
}

describe('renderer i18n runtime', () => {
  it('collects translation keys used by fallback wrappers as well as ordinary lookups', () => {
    const keys = literalTranslationKeys(path.join(rendererRoot, 'modules', 'saved-apps.js'));
    expect(keys).toContain('apps.publish_action');
    expect(keys).toContain('apps.publish_visit');
  });

  it('rejects prototype names as saved or selected languages and keeps English usable', async () => {
    const setLanguage = vi.fn(async (language) => ({ ok: true, language }));
    const { sandbox, events } = loadI18n({
      boot: { lang: 'en', tables: { en: { hello: 'Hello' } } },
      setLanguage,
    });
    for (const language of ['constructor', '__proto__', 'toString']) {
      expect(sandbox.isSupportedLang(language)).toBe(false);
      await expect(sandbox.setLang(language)).resolves.toBe('en');
    }
    expect(setLanguage).not.toHaveBeenCalled();
    expect(sandbox.t('hello')).toBe('Hello');
    expect(events).toEqual([]);
  });

  it.each([
    ['es', 'Cancelar'], ['fr', 'Annuler'], ['ko', '취소'],
    ['de', 'Abbrechen'], ['ru', 'Отмена'], ['it', 'Annulla'],
  ] as const)('renders %s before first paint and preserves the selected language on change', async (language, cancel) => {
    const text = domElement({ 'data-i18n': 'common.cancel' }, 'Cancel');
    const tables = localeTables('renderer');
    const first = loadI18n({ boot: { lang: language, tables }, textElements: [text] });
    expect(text.textContent).toBe(cancel);
    expect(first.htmlAttributes.lang).toBe(language);
    const persist = vi.fn(async (lang: string) => ({ ok: true, language: lang }));
    const second = loadI18n({ boot: { lang: 'en', tables }, textElements: [text], setLanguage: persist });
    await expect(second.sandbox.setLang(language)).resolves.toBe(language);
    expect(persist).toHaveBeenCalledWith(language);
    expect(text.textContent).toBe(cancel);
    expect(second.htmlAttributes.lang).toBe(language);
    expect(second.events).toEqual([{ type: 'i18n-change', detail: { lang: language } }]);
  });
  it('uses English fallback and raw-key fallback without blanking content', () => {
    const text = domElement({ 'data-i18n': 'only.english' }, 'default');
    const { sandbox, htmlAttributes } = loadI18n({
      boot: {
        lang: 'zh',
        tables: {
          zh: { 'only.chinese': '中文' },
          en: { 'only.english': 'English fallback' },
        },
      },
      textElements: [text],
    });

    expect(text.textContent).toBe('English fallback');
    expect(sandbox.t('only.chinese')).toBe('中文');
    expect(sandbox.t('missing.key')).toBe('missing.key');
    expect(htmlAttributes.lang).toBe('zh-CN');
  });

  it('preserves static default copy when asynchronous locale loading fails', async () => {
    const text = domElement({ 'data-i18n': 'nav.agents' }, 'Agents');
    const { sandbox, htmlAttributes, warnings } = loadI18n({
      getLanguage: async () => { throw new Error('/private/account/language'); },
      getLocales: async () => { throw new Error('/private/app/locales'); },
      textElements: [text],
    });

    await expect(sandbox.initI18n()).resolves.toBe('en');

    expect(text.textContent).toBe('Agents');
    expect(htmlAttributes.lang).toBe('en');
    expect(JSON.stringify(warnings)).not.toContain('/private/');
  });

  it('keeps the previous language and emits no event when persistence fails', async () => {
    const text = domElement({ 'data-i18n': 'nav.agents' }, 'Agents');
    const { sandbox, events, warnings } = loadI18n({
      boot: {
        lang: 'en',
        tables: {
          en: { 'nav.agents': 'Agents' },
          pt: { 'nav.agents': 'Agentes' },
        },
      },
      setLanguage: async () => ({ ok: false, error: '/private/write/failure' }),
      textElements: [text],
    });

    await expect(sandbox.setLang('pt')).rejects.toThrow('language change failed');

    expect(sandbox.getLang()).toBe('en');
    expect(text.textContent).toBe('Agents');
    expect(events).toEqual([]);
    expect(JSON.stringify(warnings)).not.toContain('/private/write/failure');
  });

  it('does not switch to a language whose table is unavailable', async () => {
    const { sandbox, events } = loadI18n({
      boot: { lang: 'en', tables: { en: { hello: 'Hello' } } },
      getLocales: async () => ({
        ok: true,
        tables: { pt: { hello: { nested: 'invalid' } } },
      }),
    });

    await expect(sandbox.setLang('pt')).rejects.toThrow('language change failed');

    expect(sandbox.getLang()).toBe('en');
    expect(events).toEqual([]);
  });

  it('serializes rapid choices and applies only the latest successful language', async () => {
    const japanese = deferred<any>();
    const portuguese = deferred<any>();
    const setLanguage = vi.fn((lang: string) => (
      lang === 'ja' ? japanese.promise : portuguese.promise
    ));
    const text = domElement({ 'data-i18n': 'nav.agents' }, 'Agents');
    const { sandbox, events, htmlAttributes } = loadI18n({
      boot: {
        lang: 'en',
        tables: {
          en: { 'nav.agents': 'Agents' },
          ja: { 'nav.agents': 'エージェント' },
          pt: { 'nav.agents': 'Agentes' },
        },
      },
      setLanguage,
      textElements: [text],
    });

    const first = sandbox.setLang('ja');
    const second = sandbox.setLang('pt');
    await new Promise((resolve) => setTimeout(resolve, 0));
    expect(setLanguage.mock.calls.map(([lang]) => lang)).toEqual(['ja']);

    japanese.resolve({ ok: true, language: 'ja' });
    await expect(first).resolves.toBe('en');
    await new Promise((resolve) => setTimeout(resolve, 0));
    expect(setLanguage.mock.calls.map(([lang]) => lang)).toEqual(['ja', 'pt']);

    portuguese.resolve({ ok: true, language: 'pt' });
    await expect(second).resolves.toBe('pt');

    expect(sandbox.getLang()).toBe('pt');
    expect(text.textContent).toBe('Agentes');
    expect(htmlAttributes.lang).toBe('pt-BR');
    expect(events).toEqual([
      { type: 'i18n-change', detail: { lang: 'pt' } },
    ]);
  });

  it('reconciles to the last persisted choice when the newest queued choice fails', async () => {
    const setLanguage = vi.fn()
      .mockResolvedValueOnce({ ok: true, language: 'ja' })
      .mockResolvedValueOnce({ ok: false, error: 'write failed' });
    const text = domElement({ 'data-i18n': 'nav.agents' }, 'Agents');
    const { sandbox, events } = loadI18n({
      boot: {
        lang: 'en',
        tables: {
          en: { 'nav.agents': 'Agents' },
          ja: { 'nav.agents': 'エージェント' },
          pt: { 'nav.agents': 'Agentes' },
        },
      },
      setLanguage,
      textElements: [text],
    });

    const first = sandbox.setLang('ja');
    const second = sandbox.setLang('pt');

    await expect(first).resolves.toBe('en');
    await expect(second).rejects.toThrow('language change failed');

    expect(sandbox.getLang()).toBe('ja');
    expect(text.textContent).toBe('エージェント');
    expect(events).toEqual([
      { type: 'i18n-change', detail: { lang: 'ja' } },
    ]);
  });

  it('does not let a stale preference refresh overwrite a newer local choice', async () => {
    const refreshedLanguage = deferred<any>();
    const getLanguage = vi.fn(() => refreshedLanguage.promise);
    const text = domElement({ 'data-i18n': 'nav.agents' }, 'Agents');
    const { sandbox, events, htmlAttributes } = loadI18n({
      boot: {
        lang: 'en',
        tables: {
          en: { 'nav.agents': 'Agents' },
          ja: { 'nav.agents': 'エージェント' },
          pt: { 'nav.agents': 'Agentes' },
        },
      },
      getLanguage,
      textElements: [text],
    });

    const staleRefresh = sandbox.refreshLangFromMain();
    await vi.waitFor(() => expect(getLanguage).toHaveBeenCalledOnce());
    await expect(sandbox.setLang('pt')).resolves.toBe('pt');
    refreshedLanguage.resolve({ ok: true, language: 'ja' });
    await expect(staleRefresh).resolves.toBe('pt');

    expect(sandbox.getLang()).toBe('pt');
    expect(text.textContent).toBe('Agentes');
    expect(htmlAttributes.lang).toBe('pt-BR');
    expect(events).toEqual([{ type: 'i18n-change', detail: { lang: 'pt' } }]);
  });

  it('updates text, placeholder, title, accessible label and document language on success', async () => {
    const text = domElement({ 'data-i18n': 'label' }, 'Label');
    const placeholder = domElement({ 'data-i18n-placeholder': 'placeholder' }, '');
    const title = domElement({ 'data-i18n-title': 'title' }, '');
    const ariaLabel = domElement({ 'data-i18n-aria-label': 'aria' }, '');
    const { sandbox, htmlAttributes } = loadI18n({
      boot: {
        lang: 'en',
        tables: {
          en: { label: 'Label', placeholder: 'Search', title: 'Help', aria: 'Close' },
          ja: { label: 'ラベル', placeholder: '検索', title: 'ヘルプ', aria: '閉じる' },
        },
      },
      textElements: [text],
      placeholderElements: [placeholder],
      titleElements: [title],
      ariaLabelElements: [ariaLabel],
    });

    await expect(sandbox.setLang('ja')).resolves.toBe('ja');

    expect(text.textContent).toBe('ラベル');
    expect(placeholder.attributes.placeholder).toBe('検索');
    expect(title.attributes.title).toBe('ヘルプ');
    expect(ariaLabel.attributes['aria-label']).toBe('閉じる');
    expect(htmlAttributes.lang).toBe('ja');
  });
});

describe('locale resource contract', () => {
  it('keeps main and Renderer language metadata synchronized', () => {
    const { sandbox } = loadI18n();
    const rendererLocales = sandbox.getSupportedLanguages().map((item: any) => ({
      code: item.code,
      htmlLang: item.htmlLang,
      intlLocale: item.intlLocale,
      fallback: item.fallback,
    }));
    const mainLocales = MAIN_LOCALES.map((item) => ({
      code: item.code,
      htmlLang: item.htmlLang,
      intlLocale: item.intlLocale,
      fallback: item.fallback,
    }));

    expect(rendererLocales).toEqual(mainLocales);
  });

  it('keeps locale key sets, value types and supported placeholders identical', () => {
    const allowedEmpty = new Set([
      'force_update.status_error',
      'memory.export_sub',
      'memory.export_foot',
      'settings.video.sub',
    ]);
    for (const side of ['main', 'renderer'] as const) {
      const tables = localeTables(side);
      const englishKeys = Object.keys(tables.en).sort();
      for (const lang of LANGS) {
        expect(Object.keys(tables[lang]).sort(), `${side}/${lang} key set`)
          .toEqual(englishKeys);
        for (const [key, value] of Object.entries(tables[lang])) {
          expect(typeof value, `${side}/${lang}:${key}`).toBe('string');
          if (!value.trim()) {
            expect(side, `${side}/${lang}:${key} unexpected empty value`).toBe('renderer');
            expect(allowedEmpty.has(key), `${side}/${lang}:${key} unexpected empty value`)
              .toBe(true);
          }
          expect(value, `${side}/${lang}:${key} unsupported double-brace placeholder`)
            .not.toMatch(/\{\{\w+\}\}/);
          expect(placeholders(value), `${side}/${lang}:${key} placeholders`)
            .toEqual(placeholders(tables.en[key]));
        }
      }
    }
  });

  it('localizes the commercial invitation guide and omits hosted account and membership notices', () => {
    const tables = localeTables('renderer');
    const removed = [
      "sidebar.alert_sync_pro_required",
      "sidebar.alert_subscription_past_due",
      "sidebar.alert_subscription_past_due_title",
      "settings.account.page_sub",
      "sidebar.alert_sync_delete_confirm",
      "sidebar.alert_sync_delete_confirm_title",
      "sidebar.alert_sync_conflicts",
      "sidebar.alert_sync_conflicts_title",
      "sidebar.alert_sync_failed",
      "sidebar.alert_sync_network",
      "sidebar.alert_sync_integrity",
      "sidebar.alert_sync_quota_full",
      "sidebar.alert_subscription_expiring",
      "sidebar.alert_subscription_expiring_title",
      "settings.account.signed_out_hint"
    ];
    const keys = Object.keys(tables.en).filter(key => key.startsWith('project.invite_members.')
      || key === 'project.menu.invite_members' || key === 'project.bindings.add_failed');
    for (const lang of LANGS) {
      for (const key of removed) expect(Object.keys(tables[lang]), `${lang}:${key}`).not.toContain(key);
      expect(Object.keys(tables[lang]).filter(key => key.startsWith('project.share.')
        || key.startsWith('account.shared_projects_'))).toEqual([]);
      if (lang === 'en') continue;
      const { sandbox } = loadI18n({ boot: { lang, tables } });
      for (const key of keys) {
        expect(sandbox.t(key), `${lang}:${key} untranslated invitation/recovery copy`).not.toBe(tables.en[key]);
        expect(sandbox.t(key), `${lang}:${key} selected language`).toBe(tables[lang][key]);
      }
    }
  });

  it('keeps shared Main and Renderer user messages semantically aligned', () => {
    const contextSpecificCopy = new Set([
      'provider.moonshot.note_paygo',
      'provider.kimi_coding.note_subscription',
      'chat.reply_interrupted',
    ]);
    const mainTables = localeTables('main');
    const rendererTables = localeTables('renderer');
    const sharedKeys = Object.keys(mainTables.en)
      .filter((key) => Object.hasOwn(rendererTables.en, key))
      .filter((key) => !contextSpecificCopy.has(key));

    for (const lang of LANGS) {
      for (const key of sharedKeys) {
        expect(rendererTables[lang][key], `${lang}:${key}`)
          .toBe(mainTables[lang][key]);
      }
    }
  });

  it('describes message actions by their user-visible effect without internal tool names', () => {
    const tables = localeTables('renderer');
    const editCopyLabels = {
      en: 'Edit copy',
      zh: '编辑副本',
      ja: 'コピーを編集',
      pt: 'Editar cópia',
    } as const;
    const sendVerbs = {
      en: /\bsend\b/i,
      zh: /发送/,
      ja: /送る|送信/,
      pt: /\benviar\b/i,
    } as const;

    for (const lang of ['en', 'zh', 'ja', 'pt'] as const) {
      expect(tables[lang]['chat.menu.scratch_edit'], `${lang}: edit selected copy`)
        .toBe(editCopyLabels[lang]);
      expect(tables[lang]['chat.md_drawer.scratch_title'], `${lang}: edited copy title`)
        .toBe(editCopyLabels[lang]);
      expect(tables[lang]['chat.md_drawer.send_to_chat'], `${lang}: add edited text`)
        .not.toMatch(sendVerbs[lang]);
      expect(tables[lang]['chat.quote_btn_title'], `${lang}: add quote`)
        .not.toMatch(sendVerbs[lang]);
      expect(tables[lang]['chat.quote_files_label'], `${lang}: attached file label`)
        .not.toContain('read_file');
      expect(tables[lang]['chat.archive_btn'], `${lang}: Library action`)
        .toBe(tables[lang]['chat.archive_btn_title']);
      expect(tables[lang]['chat.archive_btn'], `${lang}: compact Library label`)
        .toBe(tables[lang]['sidebar.contexts']);
      expect(tables[lang]['kb_picker.title_global'].toLocaleLowerCase(), `${lang}: Global Library picker`)
        .toContain(tables[lang]['contexts.transfer.global_library'].toLocaleLowerCase());
      expect(tables[lang]['kb_picker.title_project'].toLocaleLowerCase(), `${lang}: Project Library picker`)
        .toContain(tables[lang]['contexts.transfer.project_library'].toLocaleLowerCase());
    }
  });

  it('keeps parameterized translations out of static DOM bindings', () => {
    const rendererEnglish = localeTables('renderer').en;
    const html = fs.readFileSync(path.join(rendererRoot, 'index.html'), 'utf8');
    const parameterizedBindings = [
      ...html.matchAll(/\b(data-i18n(?:-placeholder|-title|-aria-label)?)="([^"]+)"/g),
    ]
      .map((match) => ({ attribute: match[1], key: match[2] }))
      .filter(({ key }) => placeholders(rendererEnglish[key] || '').length > 0);

    expect(parameterizedBindings).toEqual([]);
  });

  it('defines every literal Renderer UI key while omitting the stripped publication prompt', () => {
    const rendererEnglish = localeTables('renderer').en;
    const html = fs.readFileSync(path.join(rendererRoot, 'index.html'), 'utf8');
    const keys = [
      ...[...html.matchAll(/data-i18n(?:-placeholder|-title|-aria-label)?="([^"]+)"/g)]
        .map((match) => match[1]),
      ...fs.readdirSync(path.join(rendererRoot, 'modules'))
        .filter((name) => name.endsWith('.js'))
        .flatMap((name) => literalTranslationKeys(path.join(rendererRoot, 'modules', name))),
    ];
    // The commercial web-adaptation prompt has no public UI caller and its
    // empty fallback is intentional. It must not be restored by a copy sync.
    const missing = [...new Set(keys)].filter((key) => key !== 'apps.publish_adapt_seed'
      && !Object.hasOwn(rendererEnglish, key));

    expect(missing).toEqual([]);
    expect(rendererEnglish).not.toHaveProperty('apps.publish_adapt_seed');
  });

  it('defines every literal Main translation key referenced by TypeScript or JavaScript', () => {
    const mainEnglish = localeTables('main').en;
    const mainRoot = path.resolve(rendererRoot, '..', 'main');
    const keys = sourceFiles(mainRoot).flatMap(literalTranslationKeys);
    const missing = [...new Set(keys)].filter((key) => !Object.hasOwn(mainEnglish, key));

    expect(missing).toEqual([]);
  });

  it('contains no duplicate JSON keys in any shipped locale table', () => {
    for (const side of ['main', 'renderer'] as const) {
      for (const lang of LANGS) {
        const file = path.resolve(rendererRoot, '..', side, 'locales', `${lang}.json`);
        const raw = fs.readFileSync(file, 'utf8');
        const parsed = JSON.parse(raw);
        const rawKeys = [...raw.matchAll(/"((?:\\.|[^"\\])*)"\s*:/g)]
          .map((match) => match[1]);
        expect(rawKeys.length, `${side}/${lang} raw key count`)
          .toBe(Object.keys(parsed).length);
        expect(new Set(rawKeys).size, `${side}/${lang} duplicate key`)
          .toBe(rawKeys.length);
      }
    }
  });
});


describe('shared 1.9.5 and API-key voice translations', () => {
  const sharedKeys = ['chat.task_status_planning', 'contexts.kb.image_failed', 'contexts.kb.image_failed_hint',
    'project.todo.delete_confirm', 'project.todo.due_label',
    'project.todo.due_on', 'project.todo.due_overdue', 'project.todo.due_invalid'];
  const voiceKeys = ['chat.mic_title', 'chat.mic_stop_title', 'chat.mic_error_permission',
    'chat.mic_error_no_device', 'chat.mic_error_unavailable', 'chat.mic_insufficient_credits',
    'chat.mic_limit_reached', 'settings.orkas_api.key_required'];
  it.each(LANGS)('renders shared status, recovery and voice guidance using the selected %s table', lang => {
    const tables = localeTables('renderer');
    const { sandbox } = loadI18n({boot:{lang,tables}});
    for (const key of [...sharedKeys,...voiceKeys]) {
      expect(tables[lang][key], lang + ':' + key).toBeTypeOf('string');
      expect(tables[lang][key].trim(), lang + ':' + key).not.toBe('');
      const variables = Object.fromEntries(placeholders(tables.en[key]).map(name => [name, name === 'seconds' ? '120' : '2026-10-26']));
      const expected = tables[lang][key].replace(/\{(\w+)\}/g, (_match: string,name: string) => variables[name]);
      expect(sandbox.t(key,variables), lang + ':' + key).toBe(expected);
      expect(sandbox.t(key,variables)).not.toMatch(/\{\w+\}/);
    }
    if(lang !== 'en') for(const key of voiceKeys)
      expect(tables[lang][key], lang + ':' + key + ' translated voice recovery').not.toBe(tables.en[key]);
  });
});