euparliamentmonitor 0.9.19 → 0.9.21

package/scripts/mcp/transport/process.js

@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: 2024-2026 Hack23 AB
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @module MCP/transport/process
+ * @description Stdio process spawn / teardown helpers and JSON-RPC message routing
+ * for the MCPConnection stdio transport.
+ *
+ * Extracted from `connection.ts` to keep individual file sizes under 400 LOC.
+ * Operates on an explicit {@link SpawnContext} adapter rather than `this`.
+ */
+import { spawn } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// ─── Binary path constants ────────────────────────────────────────────────────
+/** npm binary name for the European Parliament MCP server */
+export const BINARY_NAME = 'european-parliament-mcp-server';
+/** Platform-specific binary filename (Windows uses .cmd shim) */
+export const BINARY_FILE = process.platform === 'win32' ? `${BINARY_NAME}.cmd` : BINARY_NAME;
+/** Default binary resolved from node_modules/.bin relative to this file's compiled location */
+export const DEFAULT_SERVER_BINARY = resolve(dirname(fileURLToPath(import.meta.url)), `../../../node_modules/.bin/${BINARY_FILE}`);
+/** Default request timeout in milliseconds — EU Parliament API responses commonly take 30-120+ seconds for large datasets */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 180_000;
+/**
+ * Effective request timeout, configurable via `EP_REQUEST_TIMEOUT_MS` env var.
+ * This keeps the client-side timeout aligned with the MCP server timeout set
+ * in workflow configs and copilot-mcp.json.
+ */
+export const REQUEST_TIMEOUT_MS = (() => {
+    const envVal = process.env['EP_REQUEST_TIMEOUT_MS'];
+    if (envVal) {
+        const parsed = Number(envVal);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_REQUEST_TIMEOUT_MS;
+})();
+/** Connection startup delay in milliseconds */
+export const CONNECTION_STARTUP_DELAY_MS = 500;
+// ─── Exported helpers ─────────────────────────────────────────────────────────
+/**
+ * Attempt a single connection via stdio (spawns server binary).
+ *
+ * @param ctx - Spawn context adapter from MCPConnection
+ */
+export async function attemptStdioConnection(ctx) {
+    try {
+        const isJavaScriptFile = ctx.serverPath.toLowerCase().endsWith('.js');
+        const command = isJavaScriptFile ? process.execPath : ctx.serverPath;
+        const args = isJavaScriptFile ? [ctx.serverPath] : [];
+        const childEnv = { ...process.env };
+        const envVal = childEnv['EP_REQUEST_TIMEOUT_MS'];
+        let effectiveTimeoutMs = ctx.requestTimeoutMs;
+        if (envVal !== undefined && envVal !== '') {
+            const parsed = Number(envVal);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                effectiveTimeoutMs = parsed;
+            }
+            else {
+                console.warn(`Invalid EP_REQUEST_TIMEOUT_MS value (non-finite or ≤0); falling back to ${ctx.requestTimeoutMs}ms`);
+            }
+        }
+        childEnv['EP_REQUEST_TIMEOUT_MS'] = String(effectiveTimeoutMs);
+        if (!isJavaScriptFile) {
+            args.push('--timeout', String(effectiveTimeoutMs));
+        }
+        const child = spawn(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: childEnv,
+        });
+        ctx.setProcess(child);
+        let buffer = '';
+        let startupError = null;
+        child.stdout?.on('data', (data) => {
+            buffer += data.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line.trim()) {
+                    ctx.onMessage(line);
+                }
+            }
+        });
+        child.stderr?.on('data', (data) => {
+            const message = data.toString().trim();
+            if (message) {
+                console.error(`MCP Server: ${message}`);
+            }
+        });
+        child.on('close', (code) => {
+            console.log(`MCP Server exited with code ${code}`);
+            ctx.setConnected(false);
+            ctx.rejectAllPending('MCP server connection closed');
+        });
+        child.on('error', (err) => {
+            startupError = err;
+            ctx.setConnected(false);
+        });
+        await new Promise((resolve) => setTimeout(resolve, CONNECTION_STARTUP_DELAY_MS));
+        if (startupError) {
+            throw startupError;
+        }
+        ctx.setConnected(true);
+        console.log(`✅ Connected to ${ctx.serverLabel}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error('❌ Failed to spawn MCP server:', message);
+        throw error;
+    }
+}
+/**
+ * Handle an incoming newline-delimited JSON-RPC message from the server.
+ * Routes responses to matching in-flight pending requests; logs notifications.
+ *
+ * @param line - Single JSON-RPC message line (no trailing newline)
+ * @param pending - In-flight request map maintained by {@link MCPConnection}
+ */
+export function handleIncomingMessage(line, pending) {
+    try {
+        const message = JSON.parse(line);
+        if (message.id !== null && message.id !== undefined && pending.has(message.id)) {
+            const req = pending.get(message.id);
+            if (req) {
+                pending.delete(message.id);
+                if (message.error) {
+                    req.reject(new Error(message.error.message ?? 'MCP server error'));
+                }
+                else {
+                    req.resolve(message.result);
+                }
+            }
+            else {
+                pending.delete(message.id);
+                console.error(`MCP pending request ${String(message.id)} vanished before handling`);
+            }
+        }
+        else if ((message.id === null || message.id === undefined) && message.method) {
+            console.log(`MCP Notification: ${message.method}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('Error parsing MCP message:', errorMessage);
+        console.error('Problematic line:', line);
+    }
+}
+//# sourceMappingURL=process.js.map

package/scripts/mcp/transport/reconnect.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @module MCP/transport/reconnect
+ * @description Exponential back-off reconnect loop and tool-call retry logic
+ * for MCPConnection.
+ *
+ * Extracted from `connection.ts` to keep individual file sizes under 400 LOC.
+ * Operates on an explicit {@link ReconnectOps} adapter rather than `this`.
+ */
+import type { MCPToolResult } from '../../types/index.js';
+/**
+ * Adapter passed by {@link MCPConnection} to reconnect/retry helpers.
+ * Exposes the handful of connection fields these helpers need through
+ * getter/setter callbacks so the fields remain on the connection class
+ * (preserving external observability via `getConnectionHealth()`).
+ */
+export interface ReconnectOps {
+    /** Maximum consecutive connection attempts before giving up */
+    readonly maxConnectionAttempts: number;
+    /** Base delay (ms) between retry attempts */
+    readonly connectionRetryDelay: number;
+    /** Human-readable label for log messages */
+    readonly serverLabel: string;
+    /** Call the underlying MCP tool (used by the retry loop) */
+    readonly callTool: (name: string, args: object) => Promise<MCPToolResult>;
+    /** Whether the transport is currently connected */
+    readonly isConnected: () => boolean;
+    /** Trigger a full reconnect cycle */
+    readonly connect: () => Promise<void>;
+    /** Mark the transport as (dis)connected */
+    readonly setConnected: (v: boolean) => void;
+    /** Current reconnect-attempt counter */
+    readonly getReconnectCount: () => number;
+    /** Update the reconnect-attempt counter */
+    readonly setReconnectCount: (n: number) => void;
+    /** Current in-flight reconnect promise (or null) */
+    readonly getReconnectingPromise: () => Promise<void> | null;
+    /** Persist or clear the in-flight reconnect promise */
+    readonly setReconnectingPromise: (p: Promise<void> | null) => void;
+    /** Current cumulative timeout counter */
+    readonly getTimeoutCount: () => number;
+    /** Update the cumulative timeout counter */
+    readonly setTimeoutCount: (n: number) => void;
+}
+/**
+ * Reconnect with exponential back-off. Concurrent callers await the same
+ * in-flight reconnect promise instead of spawning parallel attempts.
+ *
+ * @param ops - Reconnect operations adapter from MCPConnection
+ * @returns Promise that resolves when reconnection succeeds or all attempts are exhausted
+ */
+export declare function performReconnect(ops: ReconnectOps): Promise<void>;
+/**
+ * Log a retry warning and, if disconnected, attempt to reconnect before waiting.
+ *
+ * @param lastError - The error from the failed attempt
+ * @param attempt - Zero-based current attempt index
+ * @param retries - Total retry count
+ * @param ops - Reconnect operations adapter
+ * @returns Promise that resolves after logging, optional reconnect, and inter-retry delay
+ */
+export declare function handleRetryAttempt(lastError: Error, attempt: number, retries: number, ops: ReconnectOps): Promise<void>;
+/**
+ * Call an MCP tool with automatic retry on timeout or connection loss.
+ * Non-retriable errors are re-thrown immediately without consuming retry budget.
+ *
+ * @param name - Tool name
+ * @param args - Tool arguments (plain object, non-null, not an array)
+ * @param retries - Maximum number of retries (validated ≥ 0 by caller)
+ * @param ops - Reconnect operations adapter
+ * @returns Tool execution result
+ */
+export declare function runWithRetry(name: string, args: object, retries: number, ops: ReconnectOps): Promise<MCPToolResult>;
+//# sourceMappingURL=reconnect.d.ts.map

package/scripts/mcp/transport/reconnect.js

@@ -0,0 +1,96 @@
+// SPDX-FileCopyrightText: 2024-2026 Hack23 AB
+// SPDX-License-Identifier: Apache-2.0
+import { isRetriableError, RECONNECT_MAX_DELAY_MS } from './retry-policy.js';
+// ─── Exported helpers ─────────────────────────────────────────────────────────
+/**
+ * Reconnect with exponential back-off. Concurrent callers await the same
+ * in-flight reconnect promise instead of spawning parallel attempts.
+ *
+ * @param ops - Reconnect operations adapter from MCPConnection
+ * @returns Promise that resolves when reconnection succeeds or all attempts are exhausted
+ */
+export async function performReconnect(ops) {
+    const inflight = ops.getReconnectingPromise();
+    if (inflight !== null) {
+        return inflight;
+    }
+    ops.setReconnectCount(ops.getReconnectCount() + 1);
+    console.log(`🔄 Reconnecting to ${ops.serverLabel} (attempt ${ops.getReconnectCount()})...`);
+    const p = doReconnect(ops);
+    ops.setReconnectingPromise(p);
+    try {
+        await p;
+    }
+    finally {
+        ops.setReconnectingPromise(null);
+    }
+}
+/**
+ * Internal reconnect helper. Waits for an exponential back-off delay then
+ * delegates to `connect()`, which handles its own retry loop.
+ *
+ * @param ops - Reconnect operations adapter
+ */
+async function doReconnect(ops) {
+    const normalizedMax = Math.max(1, ops.maxConnectionAttempts);
+    const attemptIndex = Math.min(Math.max(0, ops.getReconnectCount() - 1), normalizedMax - 1);
+    const delay = Math.min(ops.connectionRetryDelay * Math.pow(2, attemptIndex), RECONNECT_MAX_DELAY_MS);
+    await new Promise((r) => setTimeout(r, delay));
+    try {
+        ops.setConnected(false);
+        await ops.connect();
+    }
+    catch (error) {
+        console.error(`❌ Reconnection to ${ops.serverLabel} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Log a retry warning and, if disconnected, attempt to reconnect before waiting.
+ *
+ * @param lastError - The error from the failed attempt
+ * @param attempt - Zero-based current attempt index
+ * @param retries - Total retry count
+ * @param ops - Reconnect operations adapter
+ * @returns Promise that resolves after logging, optional reconnect, and inter-retry delay
+ */
+export async function handleRetryAttempt(lastError, attempt, retries, ops) {
+    if (lastError.message.toLowerCase().includes('timeout')) {
+        ops.setTimeoutCount(ops.getTimeoutCount() + 1);
+        console.warn(`⏱️ Request timeout (total: ${ops.getTimeoutCount()}), retrying ${attempt + 1}/${retries}...`);
+    }
+    else {
+        console.warn(`⚠️ Request failed, retrying ${attempt + 1}/${retries}: ${lastError.message}`);
+    }
+    if (!ops.isConnected()) {
+        await performReconnect(ops);
+    }
+    await new Promise((r) => setTimeout(r, ops.connectionRetryDelay * (attempt + 1)));
+}
+/**
+ * Call an MCP tool with automatic retry on timeout or connection loss.
+ * Non-retriable errors are re-thrown immediately without consuming retry budget.
+ *
+ * @param name - Tool name
+ * @param args - Tool arguments (plain object, non-null, not an array)
+ * @param retries - Maximum number of retries (validated ≥ 0 by caller)
+ * @param ops - Reconnect operations adapter
+ * @returns Tool execution result
+ */
+export async function runWithRetry(name, args, retries, ops) {
+    let lastError = new Error(`Failed to call tool '${name}' after ${retries} retries`);
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            return await ops.callTool(name, args);
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (!isRetriableError(lastError))
+                throw lastError;
+            if (attempt === retries)
+                break;
+            await handleRetryAttempt(lastError, attempt, retries, ops);
+        }
+    }
+    throw lastError;
+}
+//# sourceMappingURL=reconnect.js.map

package/scripts/validate-brief-translations.js

@@ -34,9 +34,25 @@
  *      is a machine-readable fixed token; dropping a diagram silently breaks
  *      downstream HTML rendering.
  *
+ * **Skeleton-aware mode**: when a translation file declares itself as a
+ * Phase A skeleton via the `<!-- translation-skeleton: lang=<code> ... -->`
+ * marker (written by the `news-translate` workflow's 2-phase
+ * largeSource strategy), gates 3–7 are SKIPPED and a single
+ * `skeleton-incomplete` advisory is emitted instead. The advisory is
+ * classified as `severity: warning` and does NOT cause a non-zero exit
+ * unless `--strict-skeletons` is passed. This is intentional: emergency
+ * partial flushes (Step 4b of the translate workflow) write skeleton
+ * stubs for languages that did not reach Phase B before the wall-clock
+ * budget expired; those stubs would otherwise trigger 5+ cascading
+ * violations per file (length-floor, fixed-token-preservation,
+ * heading-parity, mermaid-parity) that drown out real defects in fully
+ * translated siblings. Real translations in the same brief continue to
+ * receive strict validation.
+ *
  * Each translation that fails any gate produces a structured report entry.
  * The process exits with code 1 if any failures are present (unless
- * `--no-fail` is passed for advisory mode).
+ * `--no-fail` is passed for advisory mode, or unless every remaining
+ * violation has `severity: warning`).
  *
  * This script is invoked by:
  *   - `npm run validate:translations`             (CI + local)
@@ -48,6 +64,8 @@
  *     [--paths <glob>...]     # validate specific translation files only
  *     [--report <path>]       # write JSON report; default stdout
  *     [--no-fail]             # exit 0 even when violations found
+ *     [--strict-skeletons]    # treat skeleton-incomplete advisories as
+ *                             # blocking violations (default: warning)
  *     [--quiet]               # suppress per-file logging
  */
 
@@ -199,6 +217,45 @@ export function countMermaidBlocks(text) {
   return countGlobal(text, MERMAID_OPENER);
 }
 
+/**
+ * Marker that the `news-translate` workflow Phase A writes at the very top
+ * of every skeleton file (before the H1 line). When the validator sees this
+ * marker it knows the file is a deliberately incomplete Phase A skeleton
+ * from an emergency partial flush and emits a single `skeleton-incomplete`
+ * advisory instead of cascading length/token/heading/mermaid violations.
+ *
+ * The marker is intentionally a forgiving regex: any HTML comment starting
+ * with `<!-- translation-skeleton` within the first 10 lines counts. This
+ * accommodates both `<!-- translation-skeleton: lang=sv phase=A -->` and
+ * the legacy `<!-- translation-skeleton -->` formats.
+ */
+export const SKELETON_MARKER_RE = /<!--\s*translation-skeleton\b/;
+
+/**
+ * Heuristic skeleton detector. A file is a skeleton if EITHER:
+ *  - it contains the explicit `SKELETON_MARKER_RE` marker in its first
+ *    10 lines (preferred, set by Phase A), OR
+ *  - it matches the fallback heuristic for older Phase A output that
+ *    pre-dates the marker convention: ≥3 H2 headings AND the number of
+ *    `<!-- pending -->` / `<PENDING>` / `PENDING` placeholders is at
+ *    least equal to the H2 count (i.e. every H2 section appears to be
+ *    an unfilled stub).
+ *
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function isSkeletonStub(text) {
+  if (typeof text !== 'string' || text.length === 0) return false;
+  const head = text.split('\n', 10).join('\n');
+  if (SKELETON_MARKER_RE.test(head)) return true;
+  // Fallback heuristic: many H2s, almost every body line is a pending marker.
+  const h2Count = countHeadings(text, 2);
+  if (h2Count < 3) return false;
+  const pendingRe = /(<!--\s*pending\s*-->|<PENDING>|\bPENDING\b)/i;
+  const pendingHits = (text.match(new RegExp(pendingRe.source, 'gi')) || []).length;
+  return pendingHits >= h2Count;
+}
+
 /**
  * Extract H2 section titles from markdown text. Mirrors the shape returned
  * by `scripts/discover-untranslated-briefs.js#extractH2Titles` so the
@@ -324,6 +381,10 @@ export function aggregateByKey(items, key) {
  * @property {string} lang
  * @property {string} gate
  * @property {string} message
+ * @property {'error'|'warning'} [severity] - When present, controls
+ *   blocking semantics: `'warning'` entries (e.g. `skeleton-incomplete`)
+ *   do not cause a non-zero exit unless `--strict-skeletons` is passed.
+ *   Omitted entries default to blocking (`'error'` equivalent).
  */
 
 /** Parse CLI argv. Exported for unit tests. */
@@ -334,6 +395,7 @@ export function parseArgs(argv) {
     report: null,
     fail: true,
     quiet: false,
+    strictSkeletons: false,
   };
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -355,6 +417,9 @@ export function parseArgs(argv) {
       case '--no-fail':
         opts.fail = false;
         break;
+      case '--strict-skeletons':
+        opts.strictSkeletons = true;
+        break;
       case '--quiet':
         opts.quiet = true;
         break;
@@ -362,7 +427,8 @@ export function parseArgs(argv) {
       case '-h':
         process.stdout.write(
           'Usage: validate-brief-translations.js [--repo-root <path>] ' +
-            '[--paths <file>...] [--report <path>] [--no-fail] [--quiet]\n'
+            '[--paths <file>...] [--report <path>] [--no-fail] ' +
+            '[--strict-skeletons] [--quiet]\n'
         );
         process.exit(0);
         break;
@@ -444,6 +510,34 @@ export function validateTranslation(translationPath, repoRoot) {
     return violations;
   }
 
+  // Skeleton short-circuit: when a translation file declares itself as a
+  // Phase A skeleton (via the `<!-- translation-skeleton -->` marker the
+  // news-translate workflow writes during emergency partial flushes), skip
+  // gates 3–7 and emit a single non-blocking `skeleton-incomplete`
+  // advisory. The marker is a deliberate contract between the workflow
+  // and this validator: an emergency partial flush is a SUCCESSFUL
+  // outcome (some real translations were saved), and the unfilled
+  // skeleton stubs for languages that did not reach Phase B should not
+  // generate 5+ cascading violations that drown out real defects in
+  // the fully translated siblings. The next scheduled run will pick up
+  // the skeleton languages via the discovery queue's missing-language
+  // detection. See `.github/workflows/news-translate.md` §"🐘
+  // LARGE-SOURCE 2-PHASE STRATEGY" and §"4b. Wall-clock safety net".
+  const targetTextEarly = fs.readFileSync(translationPath, 'utf8');
+  if (isSkeletonStub(targetTextEarly)) {
+    violations.push({
+      translationPath: rel,
+      sourcePath: sourceRel,
+      lang,
+      gate: 'skeleton-incomplete',
+      severity: 'warning',
+      message:
+        `Phase A skeleton stub — translation for "${lang}" did not reach Phase B before the wall-clock budget expired. ` +
+        `Re-queue this language on the next scheduled run; the discovery script will detect it as a missing sibling.`,
+    });
+    return violations;
+  }
+
   const sourceBytes = fs.statSync(sourcePath).size;
   const targetBytes = fs.statSync(translationPath).size;
   if (sourceBytes > 0 && targetBytes < sourceBytes * LENGTH_FLOOR_RATIO) {
@@ -458,7 +552,7 @@ export function validateTranslation(translationPath, repoRoot) {
     });
   }
 
-  const targetText = fs.readFileSync(translationPath, 'utf8');
+  const targetText = targetTextEarly;
   let englishHits = 0;
   for (const re of EN_PATTERNS) {
     if (re.test(targetText)) englishHits += 1;
@@ -503,7 +597,9 @@ export function validateTranslation(translationPath, repoRoot) {
           `Self-check before flush: \`node scripts/validate-brief-translations.js --paths ${relQuoted}\` ` +
           `(or \`--paths ${siblingGlobQuoted}\` to validate every sibling). ` +
           `Dutch example: \`IMF\` stays \`IMF\` (never \`IMV\`); \`WEO\` stays \`WEO\` ` +
-          `(never \`Wereldwijde Economische Vooruitzichten\`).`,
+          `(never \`Wereldwijde Economische Vooruitzichten\`). ` +
+          `Norwegian example: \`IMF\` forblir \`IMF\` (never \`IPF\` / \`IMV\` / ` +
+          `\`Det internasjonale valutafondet\` / \`Pengefondet\`); \`WEO\` forblir \`WEO\`.`,
       });
     }
   }
@@ -600,8 +696,9 @@ export function runValidation(translationPaths, repoRoot, { quiet = false } = {}
       allViolations.push(...v);
       if (!quiet) {
         for (const entry of v) {
+          const icon = entry.severity === 'warning' ? '⚠️' : '❌';
           process.stderr.write(
-            `❌ ${entry.translationPath} [${entry.gate}] ${entry.message}\n`
+            `${icon} ${entry.translationPath} [${entry.gate}] ${entry.message}\n`
           );
         }
       }
@@ -612,6 +709,23 @@ export function runValidation(translationPaths, repoRoot, { quiet = false } = {}
   return allViolations;
 }
 
+/**
+ * Count the entries in a violations list that should be treated as
+ * blocking (cause a non-zero exit). When `strictSkeletons` is false
+ * (the default), entries with `severity: 'warning'` — i.e. the
+ * skeleton-incomplete advisory emitted for Phase A stubs from
+ * emergency partial flushes — are not counted as blocking.
+ */
+export function countBlockingViolations(violations, { strictSkeletons = false } = {}) {
+  if (strictSkeletons) {
+    // Promote skeleton-incomplete advisories to blocking, but leave any
+    // other warning-level advisory types non-blocking so that future
+    // additions of new warning gates don't inadvertently become strict.
+    return violations.filter((v) => v.severity !== 'warning' || v.gate === 'skeleton-incomplete').length;
+  }
+  return violations.filter((v) => v.severity !== 'warning').length;
+}
+
 /** Main entry point. */
 export function main(argv) {
   const opts = parseArgs(argv);
@@ -620,12 +734,14 @@ export function main(argv) {
     : findAllTranslations(opts.repoRoot);
 
   const violations = runValidation(paths, opts.repoRoot, { quiet: opts.quiet });
+  const blocking = countBlockingViolations(violations, { strictSkeletons: opts.strictSkeletons });
 
   const report = {
     generatedAt: new Date().toISOString(),
     totals: {
       filesChecked: paths.length,
       violations: violations.length,
+      blocking,
       byGate: aggregateByKey(violations, 'gate'),
       byLang: aggregateByKey(violations, 'lang'),
     },
@@ -639,7 +755,7 @@ export function main(argv) {
     process.stdout.write(json);
   }
 
-  if (violations.length > 0 && opts.fail) {
+  if (blocking > 0 && opts.fail) {
     process.exit(1);
   }
   return report;

package/scripts/constants/articles/breaking-strings-eu.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module breaking-strings-eu
- * @description Per-language entries (en, sv, da, no, fi, de, fr) for BREAKING_STRINGS.
- */
-import type { LanguageMap, BreakingStrings } from '../../types/index.js';
-export declare const BREAKING_STRINGS_EU: Pick<LanguageMap<BreakingStrings>, 'en' | 'sv' | 'da' | 'no' | 'fi' | 'de' | 'fr'>;
-//# sourceMappingURL=breaking-strings-eu.d.ts.map

package/scripts/constants/articles/breaking-strings-global.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module breaking-strings-global
- * @description Per-language entries (es, nl, ar, he, ja, ko, zh) for BREAKING_STRINGS.
- */
-import type { LanguageMap, BreakingStrings } from '../../types/index.js';
-export declare const BREAKING_STRINGS_GLOBAL: Pick<LanguageMap<BreakingStrings>, 'es' | 'nl' | 'ar' | 'he' | 'ja' | 'ko' | 'zh'>;
-//# sourceMappingURL=breaking-strings-global.d.ts.map

package/scripts/constants/articles/dashboard-builder-eu.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module dashboard-builder-eu
- * @description Per-language entries (en, sv, da, no, fi, de, fr) for DASHBOARD_BUILDER_STRINGS.
- */
-import type { LanguageMap, DashboardBuilderStrings } from '../../types/index.js';
-export declare const DASHBOARD_BUILDER_STRINGS_EU: Pick<LanguageMap<DashboardBuilderStrings>, 'en' | 'sv' | 'da' | 'no' | 'fi' | 'de' | 'fr'>;
-//# sourceMappingURL=dashboard-builder-eu.d.ts.map

package/scripts/constants/articles/dashboard-builder-global.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module dashboard-builder-global
- * @description Per-language entries (es, nl, ar, he, ja, ko, zh) for DASHBOARD_BUILDER_STRINGS.
- */
-import type { LanguageMap, DashboardBuilderStrings } from '../../types/index.js';
-export declare const DASHBOARD_BUILDER_STRINGS_GLOBAL: Pick<LanguageMap<DashboardBuilderStrings>, 'es' | 'nl' | 'ar' | 'he' | 'ja' | 'ko' | 'zh'>;
-//# sourceMappingURL=dashboard-builder-global.d.ts.map

package/scripts/constants/articles/deep-analysis-strings-eu.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module deep-analysis-strings-eu
- * @description Per-language entries (en, sv, da, no, fi, de, fr) for DEEP_ANALYSIS_STRINGS.
- */
-import type { LanguageMap, DeepAnalysisStrings } from '../../types/index.js';
-export declare const DEEP_ANALYSIS_STRINGS_EU: Pick<LanguageMap<DeepAnalysisStrings>, 'en' | 'sv' | 'da' | 'no' | 'fi' | 'de' | 'fr'>;
-//# sourceMappingURL=deep-analysis-strings-eu.d.ts.map

package/scripts/constants/articles/deep-analysis-strings-global.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module deep-analysis-strings-global
- * @description Per-language entries (es, nl, ar, he, ja, ko, zh) for DEEP_ANALYSIS_STRINGS.
- */
-import type { LanguageMap, DeepAnalysisStrings } from '../../types/index.js';
-export declare const DEEP_ANALYSIS_STRINGS_GLOBAL: Pick<LanguageMap<DeepAnalysisStrings>, 'es' | 'nl' | 'ar' | 'he' | 'ja' | 'ko' | 'zh'>;
-//# sourceMappingURL=deep-analysis-strings-global.d.ts.map

package/scripts/constants/articles/localized-keywords-eu.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module localized-keywords-eu
- * @description Per-language entries (en, sv, da, no, fi, de, fr) for LOCALIZED_KEYWORDS.
- */
-import type { LanguageMap } from '../../types/index.js';
-export declare const LOCALIZED_KEYWORDS_EU: Pick<LanguageMap<Record<string, readonly string[]>>, 'en' | 'sv' | 'da' | 'no' | 'fi' | 'de' | 'fr'>;
-//# sourceMappingURL=localized-keywords-eu.d.ts.map

package/scripts/constants/articles/swot-builder-eu.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module swot-builder-eu
- * @description Per-language entries (en, sv, da, no, fi, de, fr) for SWOT_BUILDER_STRINGS.
- */
-import type { LanguageMap, SwotBuilderStrings } from '../../types/index.js';
-export declare const SWOT_BUILDER_STRINGS_EU: Pick<LanguageMap<SwotBuilderStrings>, 'en' | 'sv' | 'da' | 'no' | 'fi' | 'de' | 'fr'>;
-//# sourceMappingURL=swot-builder-eu.d.ts.map