@xgent-ai/skills 0.3.0 → 0.5.0

package/skills/archify/test/helpers/desktop-browser.mjs

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { ChromeVisualBrowser } from '../../bin/visual-check.mjs';
+
+// Test-only Blink settings: headless hosts may have no physical mouse.
+// Disabling touch emulation would restore those host defaults and undo this.
+const pointerSettings = '--blink-settings=availableHoverTypes=2,primaryHoverType=2,availablePointerTypes=4,primaryPointerType=4';
+
+export function desktopBrowser(chrome) {
+  return new ChromeVisualBrowser(chrome, {
+    spawnImpl: (command, args, options) => spawn(command, [pointerSettings, ...args], options),
+  });
+}
+
+export async function desktopPointerCheck(browser, session) {
+  const version = await browser.cdp.send('Browser.getVersion');
+  await browser.cdp.send('Page.addScriptToEvaluateOnNewDocument', { source: `
+    (() => {
+      // Capture the native query before controlled coarse-pointer fixtures run.
+      const query = window.matchMedia.bind(window);
+      const sample = () => ({
+        hover: query('(hover: hover)').matches,
+        fine: query('(pointer: fine)').matches,
+        combined: query('(hover: hover) and (pointer: fine)').matches,
+        anyHover: query('(any-hover: hover)').matches,
+        anyFine: query('(any-pointer: fine)').matches,
+        maxTouchPoints: navigator.maxTouchPoints,
+      });
+      window.__archifyTestPointer = { initial: sample(), sample };
+    })();
+  ` }, session);
+  return async function checkDesktopPointer() {
+    const result = await browser.cdp.send('Runtime.evaluate', {
+      expression: '({initial:__archifyTestPointer.initial,current:__archifyTestPointer.sample()})',
+      returnByValue: true,
+    }, session);
+    assert.equal(result.exceptionDetails, undefined, 'Desktop pointer diagnostics did not initialize');
+    const samples = result.result.value;
+    for (const phase of ['initial', 'current']) {
+      for (const capability of ['hover', 'fine', 'combined', 'anyHover', 'anyFine']) {
+        assert.equal(samples[phase][capability], true,
+          `Desktop pointer capability ${phase}.${capability}: ${JSON.stringify({
+            browser: version.product, platform: process.platform, pointerSettings, samples,
+          })}`);
+      }
+    }
+  };
+}

package/skills/archify/test/helpers/offline-fonts.mjs

@@ -0,0 +1,76 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import { parse } from 'parse5';
+
+const FONT_LICENSE = fs.readFileSync(new URL('../../assets/JetBrainsMono-OFL.txt', import.meta.url), 'utf8').trim();
+
+// Pinned Google Fonts v24 bytes and coverage, independent of CSS formatting.
+const EXPECTED_FACES = [
+  ['9343de2ca5d9549f792e7962375af8efb0f320c7643bfd36c884b5a30e5c396f', 'U+0460-052F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F'],
+  ['4995a9a43ac659ec32fcd8b463755cd6a07b31a6e6b3894a6a153b661cf490e2', 'U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116'],
+  ['49c3da6c9a2b279b0f1f860f5cfb1f5dc38d88a5c7be9c9b1837bbc4e3db6111', 'U+0370-0377,U+037A-037F,U+0384-038A,U+038C,U+038E-03A1,U+03A3-03FF'],
+  ['d44eb1936043a56038eb02dd70b243f379bef65783f94ec12f277550720411f1', 'U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB'],
+  ['9c38cb2d0d2d93c1ee6e21fa78db76f13ea7e15e15cc64214c7ca89b6aaa35c4', 'U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF'],
+  ['2c32b9b3ee358c119e210f6f5195f9bd34894d78a785ff2e95d60e718e400af4', 'U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD'],
+].sort(([a], [b]) => a.localeCompare(b));
+
+export function assertFontCss(css, subject) {
+  assert.ok(css.includes(FONT_LICENSE), `${subject}: missing standalone font license`);
+  const clean = css.replace(/\/\*[\s\S]*?\*\//g, '');
+  const faces = [...clean.matchAll(/@font-face\s*\{([^}]+)\}/gi)].map(([, block]) => {
+    const descriptor = (name) => block.match(new RegExp(`\\b${name}\\s*:\\s*([^;]+)`, 'i'))?.[1].trim();
+    assert.equal(descriptor('font-family')?.replace(/["']/g, ''), 'JetBrains Mono', subject);
+    assert.equal(descriptor('font-style'), 'normal', subject);
+    assert.equal(descriptor('font-weight')?.replace(/\s+/g, ' '), '400 800', subject);
+    assert.doesNotMatch(block, /\blocal\s*\(/i, `${subject}: installed fonts must not override embedded bytes`);
+    const encoded = block.match(/\bsrc\s*:\s*url\(\s*["']?data:font\/woff2;base64,([A-Za-z0-9+/=]+)["']?\s*\)/i)?.[1];
+    assert.ok(encoded, `${subject}: missing embedded WOFF2 source`);
+    const bytes = Buffer.from(encoded, 'base64');
+    assert.equal(bytes.toString('latin1', 0, 4), 'wOF2', subject);
+    return [createHash('sha256').update(bytes).digest('hex'), descriptor('unicode-range')?.replace(/\s+/g, '').toUpperCase()];
+  }).sort(([a], [b]) => a.localeCompare(b));
+  assert.deepEqual(faces, EXPECTED_FACES, `${subject}: font bytes or character coverage changed`);
+}
+
+// Parse HTML instead of scanning script/comment strings. parse5 also decodes
+// srcdoc exactly once, so each nested viewer must satisfy the contract itself.
+export function inspectDocuments(html, subject = 'artifact') {
+  const document = { subject, styles: [], scripts: [], resources: [], children: [] };
+  const remote = (value) => /^(?:https?:)?\/\//i.test(value || '');
+  function cssResources(css) {
+    const clean = css.replace(/\/\*[\s\S]*?\*\//g, '');
+    for (const match of clean.matchAll(/(?:url\(\s*|@import\s+)["']?((?:https?:)?\/\/[^"')\s;]+)/gi)) document.resources.push(match[1]);
+  }
+  function visit(node) {
+    const attrs = Object.fromEntries((node.attrs || []).map(({ name, value }) => [name, value]));
+    const text = (node.childNodes || []).filter((child) => child.nodeName === '#text').map((child) => child.value).join('');
+    if (node.tagName === 'style') { document.styles.push(text); cssResources(text); }
+    if (node.tagName === 'script') document.scripts.push(text);
+    if (attrs.style) cssResources(attrs.style);
+    for (const name of ['src', 'poster', 'data']) if (remote(attrs[name])) document.resources.push(attrs[name]);
+    if (attrs.srcset) for (const match of attrs.srcset.matchAll(/(?:^|[\s,])((?:https?:)?\/\/[^\s,]+)/g)) document.resources.push(match[1]);
+    if (['image', 'use', 'feImage'].includes(node.tagName) || (node.tagName === 'link' && /\b(stylesheet|preconnect|dns-prefetch|preload|modulepreload|prefetch|icon)\b/.test(attrs.rel || ''))) {
+      if (remote(attrs.href)) document.resources.push(attrs.href);
+    }
+    if (node.tagName === 'iframe' && attrs.srcdoc != null) document.children.push(...inspectDocuments(attrs.srcdoc, `${subject}/srcdoc[${document.children.length}]`));
+    for (const child of node.childNodes || []) visit(child);
+  }
+  visit(parse(html));
+  return [document, ...document.children];
+}
+
+export function assertOfflineArtifact(html, subject) {
+  const documents = inspectDocuments(html, subject);
+  let viewers = 0;
+  for (const document of documents) {
+    assert.deepEqual(document.resources, [], `${document.subject}: external subresource`);
+    const viewer = document.scripts.some((script) => /Archify\.readerLayout/.test(script));
+    if (viewer) {
+      assertFontCss(document.styles.join('\n'), document.subject);
+      viewers += 1;
+    }
+  }
+  assert.ok(viewers > 0, `${subject}: expected a viewer document`);
+  return viewers;
+}

package/skills/archify/test/helpers/viewer-click.mjs

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+
+// Keep native input and assert the actual event target, so a later docking
+// update cannot silently turn a missed click into an unrelated state timeout.
+function installClickObserver() {
+  const describe = el => el ? { tag: el.tagName, id: el.id, node: el.getAttribute('data-node-id') } : null;
+  const state = el => {
+    const r = el?.getBoundingClientRect();
+    const point = r ? { x: r.x + r.width / 2, y: r.y + r.height / 2 } : null;
+    const hit = point && document.elementFromPoint(point.x, point.y);
+    return {
+      point, rect: r ? [r.x, r.y, r.width, r.height] : null,
+      visible: !!el?.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true }),
+      enabled: !!el && !el.matches(':disabled,[aria-disabled="true"]'),
+      hit: describe(hit), matches: !!el && (el === hit || el.contains(hit)),
+      camera: document.querySelector('.diagram-container')?.getAttribute('data-camera-transaction'),
+      dock: document.getElementById('route-probe')?.getAttribute('data-route-dock'),
+    };
+  };
+  let listener, observation;
+  function arm(selector) {
+    if (listener) removeEventListener('click', listener, true);
+    observation = null;
+    listener = event => {
+      const el = document.querySelector(selector);
+      observation = { trusted: event.isTrusted, matches: !!el && (el === event.target || el.contains(event.target)),
+        target: describe(event.target), state: state(el), x: event.clientX, y: event.clientY };
+    };
+    addEventListener('click', listener, { capture: true, once: true });
+  }
+  window.viewerClick = {
+    async ready(selector, timeout) {
+      document.querySelector(selector)?.scrollIntoView({ block: 'nearest', inline: 'nearest', behavior: 'instant' });
+      await Archify.viewerChromeLayout.whenStable();
+      return new Promise((resolve, reject) => {
+        const start = performance.now();
+        let previous;
+        function sample() {
+          const current = state(document.querySelector(selector));
+          const stable = current.rect && previous?.every((value, i) => Math.abs(value - current.rect[i]) < 0.1);
+          if (stable && current.visible && current.enabled && current.matches && !current.camera) {
+            arm(selector);
+            return resolve(current.point);
+          }
+          if (performance.now() - start > timeout) {
+            return reject(new Error('Viewer click target not ready: ' + selector + ' ' + JSON.stringify(current)));
+          }
+          previous = current.rect;
+          requestAnimationFrame(sample);
+        }
+        requestAnimationFrame(sample);
+      });
+    },
+    finish() {
+      removeEventListener('click', listener, true);
+      listener = null;
+      return observation;
+    },
+  };
+}
+
+export async function createViewerClick({ send, run, timeout }) {
+  await send('Page.addScriptToEvaluateOnNewDocument', { source: `(${installClickObserver.toString()})();` });
+  return async selector => {
+    const point = await run(`viewerClick.ready(${JSON.stringify(selector)}, ${timeout})`);
+    await send('Input.dispatchMouseEvent', { type: 'mousePressed', ...point, button: 'left', clickCount: 1 });
+    await send('Input.dispatchMouseEvent', { type: 'mouseReleased', ...point, button: 'left', clickCount: 1 });
+    const observation = await run('viewerClick.finish()');
+    assert.ok(observation?.trusted && observation.matches,
+      `Native click missed ${selector}: ${JSON.stringify({ point, observation })}`);
+  };
+}

package/skills/archify/test/helpers/xml.mjs

@@ -0,0 +1,37 @@
+import { parse, parseFragment } from 'parse5';
+import { SaxesParser } from 'saxes';
+
+function visit(node, callback, insideSvg = false) {
+  callback(node, insideSvg);
+  const childInsideSvg = insideSvg || node.tagName === 'svg';
+  for (const child of node.childNodes || []) visit(child, callback, childInsideSvg);
+  if (node.content) visit(node.content, callback, childInsideSvg);
+}
+
+export function parseXml(source) {
+  return new SaxesParser({ xmlns: true }).write(source).close();
+}
+
+export function extractSvgs(markup, fragment = false) {
+  const document = fragment
+    ? parseFragment(markup, { sourceCodeLocationInfo: true })
+    : parse(markup, { sourceCodeLocationInfo: true });
+  const direct = [];
+  const srcdocs = [];
+
+  visit(document, (node, insideSvg) => {
+    if (node.tagName === 'svg' && !insideSvg && node.sourceCodeLocation) {
+      direct.push(markup.slice(node.sourceCodeLocation.startOffset, node.sourceCodeLocation.endOffset));
+    }
+    const srcdoc = node.attrs?.find((attribute) => attribute.name === 'srcdoc');
+    if (srcdoc) srcdocs.push(srcdoc.value);
+  });
+
+  return {
+    direct,
+    embedded: srcdocs.flatMap((srcdoc) => {
+      const nested = extractSvgs(srcdoc, true);
+      return [...nested.direct, ...nested.embedded];
+    }),
+  };
+}

package/skills/archify/test/i18n.test.mjs

@@ -0,0 +1,422 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { ChromeVisualBrowser, findChrome } from '../bin/visual-check.mjs';
+
+import {
+  SUPPORTED_LOCALES,
+  catalogKeys,
+  translateCount,
+  translateMessage,
+} from '../renderers/shared/i18n.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const skillRoot = path.resolve(__dirname, '..');
+const cli = path.join(skillRoot, 'bin/archify.mjs');
+const templatePath = path.join(skillRoot, 'assets/template.html');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archify-i18n-'));
+const chromePath = process.env.ARCHIFY_CHROME ? findChrome() : null;
+let sequence = 0;
+
+const EXAMPLES = {
+  architecture: 'web-app.architecture.json',
+  workflow: 'agent-tool-call.workflow.json',
+  sequence: 'cache-miss-request.sequence.json',
+  dataflow: 'product-analytics.dataflow.json',
+  lifecycle: 'agent-run.lifecycle.json',
+};
+
+function example(type) {
+  return JSON.parse(fs.readFileSync(path.join(skillRoot, 'examples', EXAMPLES[type]), 'utf8'));
+}
+
+const AUTHORED_TEXT_KEYS = new Set([
+  'title',
+  'subtitle',
+  'label',
+  'sublabel',
+  'tag',
+  'note',
+  'context',
+  'responsibility',
+  'classification',
+  'step',
+]);
+
+function authoredExample(type, locale) {
+  const document = example(type);
+  const authored = [];
+  let authoredIndex = 0;
+  const nextAuthoredText = () => {
+    authoredIndex += 1;
+    const value = locale === 'zh-CN'
+      ? `文案${String(authoredIndex).padStart(2, '0')}`
+      : `Copy${String(authoredIndex).padStart(2, '0')}`;
+    authored.push(value);
+    return value;
+  };
+  const rewrite = (value, path = []) => {
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => rewrite(item, [...path, index]));
+      return;
+    }
+    if (!value || typeof value !== 'object') return;
+    for (const [key, child] of Object.entries(value)) {
+      if (typeof child === 'string' && AUTHORED_TEXT_KEYS.has(key)) {
+        value[key] = nextAuthoredText();
+      } else if (key === 'items' && path.includes('cards') && Array.isArray(child)) {
+        value[key] = child.map((item) => (typeof item === 'string' ? nextAuthoredText() : item));
+      } else {
+        rewrite(child, [...path, key]);
+      }
+    }
+  };
+
+  rewrite(document);
+  document.meta.locale = locale;
+  if (!document.meta.subtitle) document.meta.subtitle = nextAuthoredText();
+  return { document, authored };
+}
+
+function run(type, document, command = 'render') {
+  const id = sequence++;
+  const input = path.join(tmp, `${id}-${type}.json`);
+  const output = path.join(tmp, `${id}-${type}.html`);
+  fs.writeFileSync(input, JSON.stringify(document));
+  const args = command === 'render'
+    ? [cli, 'render', type, input, output]
+    : [cli, 'validate', type, input, '--json'];
+  const result = spawnSync(process.execPath, args, { cwd: skillRoot, encoding: 'utf8' });
+  return {
+    ...result,
+    output,
+    html: result.status === 0 && command === 'render' ? fs.readFileSync(output, 'utf8') : '',
+  };
+}
+
+async function evaluate(browser, sessionId, expression, awaitPromise = false) {
+  const response = await browser.cdp.send('Runtime.evaluate', {
+    expression,
+    returnByValue: true,
+    awaitPromise,
+  }, sessionId);
+  if (response.exceptionDetails) {
+    throw new Error(response.exceptionDetails.exception?.description
+      || response.exceptionDetails.text
+      || 'browser evaluation failed');
+  }
+  return response.result?.value;
+}
+
+async function loadArtifact(browser, artifactPath) {
+  const sessionId = await browser.sessionPromise;
+  await browser.cdp.send('Emulation.setDeviceMetricsOverride', {
+    width: 1440,
+    height: 900,
+    deviceScaleFactor: 1,
+    mobile: false,
+  }, sessionId);
+  const loaded = browser.cdp.waitFor('Page.loadEventFired', sessionId);
+  const navigation = await browser.cdp.send('Page.navigate', {
+    url: pathToFileURL(artifactPath).href,
+  }, sessionId);
+  if (navigation.errorText) throw new Error(`Chrome navigation failed: ${navigation.errorText}`);
+  await loaded;
+  await evaluate(browser, sessionId, `new Promise(function (resolve) {
+    requestAnimationFrame(function () { requestAnimationFrame(function () { resolve(true); }); });
+  })`, true);
+  return sessionId;
+}
+
+test('zh-CN localizes renderer-owned output across all five modes without translating authored content', () => {
+  assert.deepEqual(SUPPORTED_LOCALES, ['en', 'zh-CN']);
+  for (const type of Object.keys(EXAMPLES)) {
+    const document = example(type);
+    const authoredTitle = document.meta.title;
+    document.meta.locale = 'zh-CN';
+    delete document.meta.subtitle;
+
+    const result = run(type, document);
+    assert.equal(result.status, 0, `${type}: ${result.stderr || result.stdout}`);
+    assert.match(result.html, /^<!DOCTYPE html>\n<html lang="zh-CN"/);
+    assert.match(result.html, /<svg\b[^>]*\blang="zh-CN"/);
+    assert.ok(result.html.includes(`<title>${authoredTitle}</title>`), `${type}: authored title changed`);
+    assert.ok(result.html.includes(`<h1>${authoredTitle}</h1>`), `${type}: authored heading changed`);
+    assert.match(result.html, /<text\b[^>]*>\u56fe\u4f8b<\/text>/);
+    assert.match(result.html, /aria-label="\u805a\u7126/);
+    assert.match(result.html, new RegExp(`<desc id="archify-diagram-description">\u7531 Archify \u751f\u6210\u7684`));
+    assert.match(result.html, /"locale":"zh-CN"/);
+    assert.match(result.html, />\u5bfc\u51fa\u56fe\u8868</);
+    assert.doesNotMatch(result.html, /\{\{i18n:/);
+  }
+});
+
+test('explicit en and zh-CN preserve complete authored field inventories across all five modes', () => {
+  for (const type of Object.keys(EXAMPLES)) {
+    const english = authoredExample(type, 'en');
+    const chinese = authoredExample(type, 'zh-CN');
+    assert.equal(english.authored.length, chinese.authored.length, `${type}: authored shapes differ`);
+    assert.ok(english.authored.length >= 10, `${type}: authored inventory is unexpectedly small`);
+    if (type === 'dataflow') {
+      assert.ok(
+        english.authored.includes(english.document.flows[0].classification),
+        'dataflow: classification is missing from the authored inventory',
+      );
+    }
+    if (type === 'lifecycle') {
+      assert.ok(
+        english.authored.includes(english.document.states[0].step),
+        'lifecycle: step is missing from the authored inventory',
+      );
+    }
+
+    for (const candidate of [english, chinese]) {
+      const locale = candidate.document.meta.locale;
+      const result = run(type, candidate.document);
+      assert.equal(result.status, 0, `${type}/${locale}: ${result.stderr || result.stdout}`);
+      assert.match(result.html, new RegExp(`^<!DOCTYPE html>\\n<html lang="${locale}"`));
+      assert.match(result.html, new RegExp(`<svg\\b[^>]*\\blang="${locale}"`));
+      assert.match(result.html, new RegExp(`"locale":"${locale}"`));
+      for (const authoredText of candidate.authored) {
+        assert.ok(result.html.includes(authoredText), `${type}/${locale}: lost authored text ${authoredText}`);
+      }
+      if (locale === 'zh-CN') {
+        assert.ok(result.html.includes(`<title>${candidate.document.meta.title}</title>`), type);
+        assert.match(result.html, />导出图表</);
+      } else {
+        assert.ok(result.html.includes(`<title>${candidate.document.meta.title} Diagram</title>`), type);
+        assert.match(result.html, />Export diagram</);
+      }
+    }
+  }
+});
+
+test('omitted locale preserves non-English authored content and the English Viewer contract in all five modes', () => {
+  for (const type of Object.keys(EXAMPLES)) {
+    const document = example(type);
+    const authoredTitle = `作者内容-${type}`;
+    document.meta.title = authoredTitle;
+    delete document.meta.locale;
+    delete document.meta.subtitle;
+
+    const result = run(type, document);
+    assert.equal(result.status, 0, `${type}: ${result.stderr || result.stdout}`);
+    assert.match(result.html, /^<!DOCTYPE html>\n<html lang="en"/);
+    assert.ok(result.html.includes(`<title>${authoredTitle} Diagram</title>`), `${type}: authored title changed`);
+    assert.ok(result.html.includes(`<h1>${authoredTitle}</h1>`), `${type}: authored heading changed`);
+    assert.match(result.html, /<svg\b[^>]*\blang="en"/);
+    assert.match(result.html, /aria-label="Focus /);
+    assert.match(result.html, /"locale":"en"/);
+    assert.match(result.html, />Export diagram</);
+  }
+});
+
+test('unsupported locale values fail schema validation in every mode', () => {
+  for (const locale of ['fr', 'zh-HK']) {
+    for (const type of Object.keys(EXAMPLES)) {
+      const document = example(type);
+      document.meta.locale = locale;
+      const result = run(type, document, 'validate');
+      assert.notEqual(result.status, 0, `${type}: unsupported locale ${locale} unexpectedly passed`);
+      const payload = JSON.parse(result.stdout);
+      assert.equal(payload.ok, false);
+      assert.ok(payload.diagnostics.some((entry) => entry.subject?.path === '/meta/locale'), `${type}: ${locale}`);
+    }
+  }
+});
+
+test('real Chrome keeps zh-CN Finder, Route, Export, and accessibility UI localized in all five modes', {
+  skip: chromePath ? false : 'Set ARCHIFY_CHROME to run the real browser localization regression.',
+}, async () => {
+  const browser = new ChromeVisualBrowser(chromePath);
+  try {
+    for (const type of Object.keys(EXAMPLES)) {
+      const document = example(type);
+      document.meta.locale = 'zh-CN';
+      document.meta.title = `浏览器本地化-${type}`;
+      const result = run(type, document);
+      assert.equal(result.status, 0, `${type}: ${result.stderr || result.stdout}`);
+
+      const sessionId = await loadArtifact(browser, result.output);
+      const state = await evaluate(browser, sessionId, `(function () {
+        var finderButton = document.getElementById('btn-node-finder');
+        var routeButton = document.getElementById('btn-route-probe');
+        var exportButton = document.getElementById('btn-export');
+        finderButton.click();
+        var finder = {
+          hidden: document.getElementById('node-finder').hidden,
+          title: document.getElementById('node-finder-title').textContent.trim(),
+          searchLabel: document.getElementById('node-finder-input').getAttribute('aria-label')
+        };
+        document.getElementById('node-finder-close').click();
+        routeButton.click();
+        var route = {
+          hidden: document.getElementById('route-probe').hidden,
+          title: document.getElementById('route-probe-title').textContent.trim(),
+          label: routeButton.getAttribute('aria-label')
+        };
+        routeButton.click();
+        exportButton.click();
+        var exportMenu = document.getElementById('export-menu');
+        function pseudoContent(selector) {
+          var content = getComputedStyle(document.querySelector(selector), '::after').content || '';
+          return content.replace(/^["']|["']$/g, '');
+        }
+        var presetBadges = {};
+        ['signal-flow', 'blueprint', 'editorial'].forEach(function (preset) {
+          document.documentElement.setAttribute('data-preset', preset);
+          presetBadges[preset] = {
+            header: pseudoContent('.header-row'),
+            plate: pseudoContent('.diagram-container')
+          };
+        });
+        return {
+          htmlLang: document.documentElement.lang,
+          svgLang: document.querySelector('.diagram-container svg').getAttribute('lang'),
+          toolbarLabel: document.querySelector('.diagram-nav').getAttribute('aria-label'),
+          finder: finder,
+          route: route,
+          exportMenuOpen: exportMenu.classList.contains('open'),
+          exportLabel: exportButton.getAttribute('aria-label'),
+          exportMenuLabel: exportMenu.getAttribute('aria-label'),
+          exportMenuText: exportMenu.textContent,
+          presetBadges: presetBadges
+        };
+      })()`);
+
+      assert.equal(state.htmlLang, 'zh-CN', type);
+      assert.equal(state.svgLang, 'zh-CN', type);
+      assert.equal(state.toolbarLabel, '图表视图控制', type);
+      assert.deepEqual(state.finder, {
+        hidden: false,
+        title: '查找节点',
+        searchLabel: '搜索图表节点',
+      }, type);
+      assert.deepEqual(state.route, {
+        hidden: false,
+        title: '选择起点节点',
+        label: '清除已追踪路径',
+      }, type);
+      assert.equal(state.exportMenuOpen, true, type);
+      assert.equal(state.exportLabel, '导出图表', type);
+      assert.equal(state.exportMenuLabel, '导出', type);
+      assert.match(state.exportMenuText, /分享卡片/, type);
+      assert.deepEqual(state.presetBadges, {
+        'signal-flow': { header: '信号流', plate: 'none' },
+        blueprint: { header: '蓝图 / 修订 01', plate: '' },
+        editorial: { header: '编辑风格 / 现场笔记', plate: 'ARCHIFY / 图版 04' },
+      }, type);
+
+      const shareCardFailure = await evaluate(browser, sessionId, `(async function () {
+        var originalGetContext = HTMLCanvasElement.prototype.getContext;
+        HTMLCanvasElement.prototype.getContext = function () { return null; };
+        try {
+          await Archify.exportMenu.shareCard();
+          return { rejected: false, message: '' };
+        } catch (error) {
+          return { rejected: true, message: String(error && error.message || error) };
+        } finally {
+          HTMLCanvasElement.prototype.getContext = originalGetContext;
+        }
+      })()`, true);
+      assert.deepEqual(shareCardFailure, {
+        rejected: true,
+        message: '无法为分享卡片创建二维画布上下文',
+      }, type);
+
+      const visual = spawnSync(process.execPath, [cli, 'visual-check', result.output, '--json'], {
+        cwd: skillRoot,
+        encoding: 'utf8',
+        env: { ...process.env, ARCHIFY_CHROME: chromePath },
+      });
+      assert.ok([0, 1].includes(visual.status), `${type}: ${visual.stderr || visual.stdout}`);
+      const receipt = JSON.parse(visual.stdout);
+      assert.equal(receipt.visualReview, 'pending', type);
+      assert.equal(receipt.chrome.status, 'available', type);
+      assert.equal(receipt.readability.status, 'pass', type);
+      assert.equal(receipt.viewerChrome.status, 'pass', type);
+      assert.equal(receipt.captures.status, 'pass', type);
+      assert.equal(
+        receipt.containment.viewports.every((viewport) => viewport.overflowX === false),
+        true,
+        `${type}: localized Viewer introduced horizontal overflow`,
+      );
+    }
+  } finally {
+    await browser.close();
+  }
+});
+
+test('every Viewer message reference resolves through the shared catalog', () => {
+  const template = fs.readFileSync(templatePath, 'utf8');
+  const keys = new Set(catalogKeys());
+  const references = new Set([
+    ...[...template.matchAll(/\{\{i18n:([a-zA-Z0-9_.-]+)\}\}/g)].map((match) => match[1]),
+    ...[...template.matchAll(/['"](viewer\.[a-zA-Z0-9_.-]+)['"]/g)].map((match) => match[1]),
+  ]);
+  const unresolved = [...references].filter((key) => (
+    !key.endsWith('.') && !keys.has(key) && !(keys.has(`${key}.one`) && keys.has(`${key}.other`))
+  ));
+  assert.deepEqual(unresolved, []);
+});
+
+test('every supported catalog is complete and preserves interpolation variables', () => {
+  const variables = (value) => [...value.matchAll(/\{([a-zA-Z0-9_]+)\}/g)]
+    .map((match) => match[1])
+    .sort();
+  for (const key of catalogKeys()) {
+    const expected = variables(translateMessage('en', key));
+    for (const locale of SUPPORTED_LOCALES) {
+      const message = translateMessage(locale, key);
+      assert.ok(message && message !== 'undefined', `${locale}: ${key}`);
+      assert.deepEqual(variables(message), expected, `${locale}: ${key}`);
+    }
+  }
+});
+
+test('runtime labels stay localized after composition', () => {
+  assert.equal(translateMessage('zh-CN', 'viewer.kind.backend'), '后端');
+  assert.equal(translateMessage('zh-CN', 'viewer.kind.decision'), '决策');
+  assert.equal(translateMessage('zh-CN', 'viewer.passport.relationship.connectsFrom'), '连接自');
+  assert.equal(translateMessage('zh-CN', 'viewer.nav.level.auto'), '自动');
+
+  const zhHops = translateCount('zh-CN', 'viewer.route.hop', 2);
+  assert.equal(
+    translateMessage('zh-CN', 'viewer.finder.result.routeTarget', { label: '终点', links: zhHops }),
+    '选择终点作为路径终点，2 跳',
+  );
+  const enHop = translateCount('en', 'viewer.route.overview.hop', 1);
+  const enNode = translateCount('en', 'viewer.route.overview.node', 2);
+  assert.equal(
+    translateMessage('en', 'viewer.route.overview.status', { nodes: enNode, hops: enHop }),
+    '2 nodes · 1 directed hop · shortest authored route',
+  );
+
+});
+
+test('Share Card and export failures use catalog messages instead of fixed English', () => {
+  assert.equal(
+    translateCount('zh-CN', 'viewer.export.card.routeSummary', 2, { source: '来源', target: '目标' }),
+    '路径：来源 → 目标 · 2 个有向跳转',
+  );
+  assert.equal(
+    translateMessage('zh-CN', 'viewer.export.error.toBlobNull', { label: '分享卡片' }),
+    '分享卡片的 canvas.toBlob 未返回数据',
+  );
+
+  const template = fs.readFileSync(templatePath, 'utf8');
+  for (const hardcoded of [
+    "'Route: '",
+    "'Share Card variants cannot be combined'",
+    "canvas2dOrThrow(canvas, 'Share Card')",
+    "'Share Card export could not remove temporary viewer state'",
+    "'WebM motion export requires a trace animation and browser MediaRecorder support'",
+  ]) {
+    assert.ok(!template.includes(hardcoded), hardcoded);
+  }
+});