@vmz/vmz 0.1.16 → 0.1.18

package/dist/locale-runtime.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Locale runtime: LocaleContext · FormatterContext · negotiation ·
  * atomic LocaleTransition · SSR/client parity.
@@ -7,20 +6,9 @@
  */
 import { createHash } from 'node:crypto';
 import { DIAG_FORMATTER_CONTEXT_INCOMPLETE, DIAG_FORMATTER_VERSION_MISMATCH, DIAG_LOCALE_DIGEST_MISMATCH, DIAG_LOCALE_MACHINE_DEFAULT_FORBIDDEN, DIAG_LOCALE_STALE_GENERATION, DIAG_LOCALE_TRANSITION_LOAD_FAILED, DIAG_LOCALE_TRANSITION_PARTIAL, DIAG_LOCALE_TRANSITION_UNSUPPORTED, DIAG_MESSAGE_MIXED_LOCALE, FORMATTER_DATA_VERSION, LOCALE_APPLICATION_CONTEXT_SCHEMA, LOCALE_FALLBACK_RESOLUTION_SCHEMA, LOCALE_FORMATTER_CONTEXT_SCHEMA, LOCALE_RUNTIME_CHECK_SCHEMA, LOCALE_TRANSITION_SCHEMA, } from './locale-schema.js';
-/**
- * Fixed negotiation priority (locale notes ). Host only supplies candidates.
- * @param {{
- * supportedLocales: string[],
- * defaultLocale: string,
- * routeLocale?: string|null,
- * userChoice?: string|null,
- * preference?: string|null,
- * hostCandidates?: string[],
- * }} input
- */
+/** Fixed negotiation priority. Host only supplies candidates. */
 export function negotiateLocale(input) {
     const supported = new Set(input.supportedLocales || []);
-    /** @param {string|null|undefined} id */
     const accept = (id) => {
         if (!id || typeof id !== 'string')
             return null;
@@ -33,18 +21,6 @@ export function negotiateLocale(input) {
         (input.hostCandidates || []).map(accept).find(Boolean) ||
         input.defaultLocale);
 }
-/**
- * @param {{
- * applicationId: string,
- * deliveryId: string,
- * localeId: string,
- * timeZone: string,
- * calendar?: string,
- * numberingSystem?: string,
- * direction?: string,
- * generation?: number,
- * }} opts
- */
 export function buildApplicationContext(opts) {
     return {
         schema: LOCALE_APPLICATION_CONTEXT_SCHEMA,
@@ -58,10 +34,6 @@ export function buildApplicationContext(opts) {
         generation: opts.generation ?? 1,
     };
 }
-/**
- * @param {ReturnType<typeof buildApplicationContext>} app
- * @param {{ currency?: string }} [opts]
- */
 export function buildFormatterContext(app, opts = {}) {
     return {
         schema: LOCALE_FORMATTER_CONTEXT_SCHEMA,
@@ -73,10 +45,7 @@ export function buildFormatterContext(app, opts = {}) {
         formatterDataVersion: FORMATTER_DATA_VERSION,
     };
 }
-/**
- * Stable digest for Resume / SSR↔client parity.
- * @param {ReturnType<typeof buildFormatterContext>} formatter
- */
+/** Stable digest for Resume / SSR↔client parity. */
 export function formatterContextDigest(formatter) {
     const canonical = {
         schema: formatter.schema,
@@ -89,13 +58,8 @@ export function formatterContextDigest(formatter) {
     };
     return createHash('sha256').update(JSON.stringify(canonical)).digest('hex').slice(0, 32);
 }
-/**
- * Server must not read machine locale/timezone defaults.
- * @param {ReturnType<typeof buildFormatterContext>} formatter
- * @param {{ allowMachineDefault?: boolean }} [opts]
- */
+/** Server must not read machine locale/timezone defaults. */
 export function validateFormatterContext(formatter, opts = {}) {
-    /** @type {Array<{code:string,severity:string,message:string}>} */
     const diagnostics = [];
     if (!formatter?.localeId || !formatter?.timeZone) {
         diagnostics.push({
@@ -133,15 +97,7 @@ export function validateFormatterContext(formatter, opts = {}) {
         diagnostics,
     };
 }
-/**
- * Resolve one MessageBinding to a single locale variant (whole-message, no mix).
- * @param {{
- * messageId: string,
- * requestedLocale: string,
- * variants: Record<string, { template: string }>,
- * fallback?: Record<string, string[]>,
- * }} input
- */
+/** Resolve one MessageBinding to a single locale variant (whole-message, no mix). */
 export function resolveMessageVariant(input) {
     const fallback = input.fallback || {};
     const chain = [input.requestedLocale, ...(fallback[input.requestedLocale] || [])];
@@ -171,8 +127,6 @@ export function resolveMessageVariant(input) {
 }
 /**
  * Minimal ICU MessageFormat subset for parity proofs (params + plural + #).
- * @param {string} template
- * @param {Record<string, any>} [args]
  */
 export function formatMessageTemplate(template, args = {}) {
     let text = String(template || '');
@@ -202,27 +156,11 @@ export function formatMessageTemplate(template, args = {}) {
     });
     return text;
 }
-/**
- * @param {{
- * applicationId: string,
- * deliveryId: string,
- * supportedLocales: string[],
- * defaultLocale: string,
- * fallback?: Record<string, string[]>,
- * directions?: Record<string, string>,
- * messages: Record<string, { variants: Record<string, { template: string }> }>,
- * initialLocaleId: string,
- * timeZone: string,
- * generation?: number,
- * loadedChunks?: Set<string>|string[],
- * }} opts
- */
 export function createLocaleSession(opts) {
     const supported = new Set(opts.supportedLocales);
     const directions = opts.directions || {};
     const fallback = opts.fallback || {};
     let generation = opts.generation ?? 1;
-    /** @type {Set<string>} */
     const loaded = new Set(opts.loadedChunks || [opts.initialLocaleId]);
     let app = buildApplicationContext({
         applicationId: opts.applicationId,
@@ -243,14 +181,9 @@ export function createLocaleSession(opts) {
             generation,
         };
     }
-    /**
-     * Render all known messages under current locale (atomic surface proof).
-     * @param {Record<string, Record<string, any>>} [argMap]
-     */
+    /** Render all known messages under current locale (atomic surface proof). */
     function renderAll(argMap = {}) {
-        /** @type {Record<string, { text: string, resolvedLocale: string }>} */
         const out = {};
-        /** @type {string[]} */
         const resolvedLocales = [];
         for (const [messageId, node] of Object.entries(opts.messages)) {
             const res = resolveMessageVariant({
@@ -270,15 +203,7 @@ export function createLocaleSession(opts) {
         const unique = [...new Set(resolvedLocales)];
         return { bindings: out, resolvedLocales: unique };
     }
-    /**
-     * Atomic LocaleTransition (locale notes ).
-     * @param {string} targetLocaleId
-     * @param {{
-     * generation?: number,
-     * loadChunk?: (localeId: string) => boolean|Promise<boolean>,
-     * timeZone?: string,
-     * }} [transitionOpts]
-     */
+    /** Atomic LocaleTransition. */
     async function transition(targetLocaleId, transitionOpts = {}) {
         const fromLocale = app.localeId;
         const expectedGen = transitionOpts.generation ?? generation;
@@ -363,7 +288,6 @@ export function createLocaleSession(opts) {
         // After commit, every binding must resolve under the new requested locale
         // (or its explicit fallback chain) — never a mix of independent "half pages".
         const foreign = rendered.resolvedLocales.filter((loc) => loc !== targetLocaleId && !(fallback[targetLocaleId] || []).includes(loc));
-        /** @type {any[]} */
         const diagnostics = [];
         if (foreign.length) {
             diagnostics.push({
@@ -404,15 +328,8 @@ export function createLocaleSession(opts) {
         },
     };
 }
-/**
- * SSR and client must share the same resolved FormatterContext digest and texts.
- * @param {{
- * ssr: { localeId: string, formatterDigest: string, formatterDataVersion?: string, texts: Record<string, string> },
- * client: { localeId: string, formatterDigest: string, formatterDataVersion?: string, texts: Record<string, string> },
- * }} input
- */
+/** SSR and client must share the same resolved FormatterContext digest and texts. */
 export function checkSsrClientParity(input) {
-    /** @type {Array<{code:string,severity:string,message:string}>} */
     const diagnostics = [];
     const { ssr, client } = input;
     if (ssr.localeId !== client.localeId) {
@@ -455,24 +372,13 @@ export function checkSsrClientParity(input) {
         diagnostics,
     };
 }
-/**
- * Aggregate runtime proof for a project check report + explicit contexts.
- * @param {{
- * manifest: { defaultLocale: string, locales: Array<{id:string,direction?:string}>, fallback?: Record<string,string[]> },
- * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- * applicationId?: string,
- * deliveryId?: string,
- * timeZone?: string,
- * }} input
- */
+/** Aggregate runtime proof for a project check report + explicit contexts. */
 export function checkLocaleRuntime(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const supported = (input.manifest?.locales || []).map((l) => l.id);
     const defaultLocale = input.manifest?.defaultLocale;
     const fallback = input.manifest?.fallback || {};
     const directions = Object.fromEntries((input.manifest?.locales || []).map((l) => [l.id, l.direction || 'ltr']));
-    /** @type {Record<string, { variants: Record<string, { template: string }> }>} */
     const messages = {};
     for (const m of input.messages || []) {
         messages[m.messageId] = { variants: m.variants };

package/dist/locale-schema.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Locale – schema constants & diagnostic codes.
  */

package/dist/locale-tooling.d.ts

@@ -1,17 +1,18 @@
-/**
- * Explain one MessageId: definition, params, variants, fallback, delivery reachability.
- * @param {{
- * messageId: string,
- * locale?: string|null,
- * deliveryId?: string|null,
- * checkReport: any,
- * }} input
- */
-export declare function explainLocaleMessage(input: any): {
+/** Explain one MessageId: definition, params, variants, fallback, delivery reachability. */
+export declare function explainLocaleMessage(input: {
+    messageId: string;
+    locale?: string | null;
+    deliveryId?: string | null;
+    checkReport: any;
+}): {
     schema: string;
     status: string;
-    messageId: any;
-    diagnostics: any[];
+    messageId: string;
+    diagnostics: {
+        code: string;
+        severity: string;
+        message: string;
+    }[];
     catalogId?: undefined;
     params?: undefined;
     variants?: undefined;
@@ -23,45 +24,62 @@ export declare function explainLocaleMessage(input: any): {
 } | {
     schema: string;
     status: string;
-    messageId: any;
+    messageId: string;
     catalogId: any;
     params: any;
     variants: {
         [k: string]: {
-            template: any;
-            path: any;
-            params: any;
+            template: string;
+            path: string;
+            params: unknown;
         };
     };
     requestedLocale: any;
-    resolvedLocale: any;
-    fallbackPath: any[];
+    resolvedLocale: string;
+    fallbackPath: string[];
     formatterDataVersion: string;
     delivery: {
-        deliveryId: any;
+        deliveryId: string;
         reachable: boolean;
-        catalogHash: any;
-        bundledLocales: any[];
+        catalogHash: string;
+        bundledLocales: string[];
     };
-    diagnostics: any[];
+    diagnostics: {
+        code: string;
+        severity: string;
+        message: string;
+    }[];
 };
-/**
- * Diff two locales' catalogs.
- * @param {{
- * baseLocale: string,
- * targetLocale: string,
- * messages: Array<{ messageId: string, variants: Record<string, { template: string, params?: any[] }> }>,
- * }} input
- */
-export declare function diffLocaleCatalogs(input: any): {
+export interface MessageCatalogEntry {
+    messageId: string;
+    variants: Record<string, {
+        template: string;
+        params?: unknown[];
+        path?: string;
+    }>;
+}
+/** Diff two locales' catalogs. */
+export declare function diffLocaleCatalogs(input: {
+    baseLocale: string;
+    targetLocale: string;
+    messages: MessageCatalogEntry[];
+}): {
     schema: string;
     status: string;
-    baseLocale: any;
-    targetLocale: any;
-    missingInTarget: any[];
-    missingInBase: any[];
-    changed: any[];
-    paramMismatches: any[];
+    baseLocale: string;
+    targetLocale: string;
+    missingInTarget: string[];
+    missingInBase: string[];
+    changed: {
+        messageId: string;
+        base: string;
+        target: string;
+    }[];
+    paramMismatches: {
+        messageId: string;
+        baseParams: unknown[];
+        targetParams: unknown[];
+    }[];
     summary: {
         missingInTarget: number;
         missingInBase: number;
@@ -72,47 +90,66 @@ export declare function diffLocaleCatalogs(input: any): {
 /**
  * Scan source for likely hardcoded UI text sinks (extract --check).
  * Does not auto-generate MessageIds.
- * @param {string} projectRoot
- * @param {{ check?: boolean }} [opts]
  */
-export declare function extractHardcodedText(projectRoot: any, opts?: {}): {
+export declare function extractHardcodedText(projectRoot: string, opts?: {
+    check?: boolean;
+}): {
     schema: string;
     status: string;
-    findings: any[];
-    diagnostics: any[];
+    findings: {
+        path: string;
+        kind: string;
+        text: string;
+        suggestion: string;
+    }[];
+    diagnostics: {
+        code: string;
+        severity: string;
+        message: string;
+        path?: string;
+    }[];
 };
 /**
  * Pseudo-localize a source locale for layout/overflow testing.
  * Preserves ICU placeholders; marks provenance — never a production fallback.
- * @param {{
- * sourceLocale: string,
- * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- * production?: boolean,
- * }} input
  */
-export declare function pseudoLocalizeCatalog(input: any): {
+export declare function pseudoLocalizeCatalog(input: {
+    sourceLocale: string;
+    messages: Array<{
+        messageId: string;
+        variants: Record<string, {
+            template: string;
+        }>;
+    }>;
+    production?: boolean;
+}): {
     schema: string;
     status: string;
-    sourceLocale: any;
+    sourceLocale: string;
     pseudoLocale: string;
     provenance: string;
-    catalog: {};
-    diagnostics: any[];
+    catalog: Record<string, string>;
+    diagnostics: {
+        code: string;
+        severity: string;
+        message: string;
+    }[];
 };
-/**
- * Cross-host conformance: same MessageId set + catalog hashes + formatter version.
- * @param {{
- * manifest: any,
- * messages: any[],
- * routeIds?: string[],
- * }} input
- */
-export declare function checkLocaleConformance(input: any): {
+/** Cross-host conformance: same MessageId set + catalog hashes + formatter version. */
+export declare function checkLocaleConformance(input: {
+    manifest: any;
+    messages: any[];
+    routeIds?: string[];
+}): {
     schema: string;
     status: string;
     hosts: string[];
     formatterDataVersion: string;
-    messageIds: any;
-    catalogHashes: {};
-    diagnostics: any[];
+    messageIds: any[];
+    catalogHashes: Record<string, string>;
+    diagnostics: {
+        code: string;
+        severity: string;
+        message: string;
+    }[];
 };

package/dist/locale-tooling.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Locale tooling: explain · diff · extract · pseudo · cross-host conformance.
  */
@@ -7,17 +6,8 @@ import path from 'node:path';
 import { DIAG_LOCALE_CONFORMANCE_DIVERGENCE, DIAG_LOCALE_EXPLAIN_UNKNOWN, DIAG_LOCALE_HARDCODED_TEXT, DIAG_LOCALE_PSEUDO_PRODUCTION_FORBIDDEN, DIAG_MESSAGE_DYNAMIC_ID_UNBOUNDED, FORMATTER_DATA_VERSION, LOCALE_CONFORMANCE_SCHEMA, LOCALE_DIFF_SCHEMA, LOCALE_EXPLAIN_SCHEMA, LOCALE_EXTRACT_SCHEMA, LOCALE_PSEUDO_SCHEMA, } from './locale-schema.js';
 import { resolveMessageVariant } from './locale-runtime.js';
 import { assertHostMessageInvariant, buildLocaleDeliveryResolution } from './locale-delivery.js';
-/**
- * Explain one MessageId: definition, params, variants, fallback, delivery reachability.
- * @param {{
- * messageId: string,
- * locale?: string|null,
- * deliveryId?: string|null,
- * checkReport: any,
- * }} input
- */
+/** Explain one MessageId: definition, params, variants, fallback, delivery reachability. */
 export function explainLocaleMessage(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const messages = input.checkReport?.messageCatalog?.messages || [];
     const node = messages.find((m) => m.messageId === input.messageId);
@@ -63,7 +53,10 @@ export function explainLocaleMessage(input) {
         messageId: input.messageId,
         catalogId: node.catalogId,
         params: base?.params || [],
-        variants: Object.fromEntries(Object.entries(node.variants || {}).map(([loc, v]) => [loc, { template: v.template, path: v.path, params: v.params }])),
+        variants: Object.fromEntries(Object.entries(node.variants || {}).map(([loc, v]) => {
+            const variant = v;
+            return [loc, { template: variant.template, path: variant.path, params: variant.params }];
+        })),
         requestedLocale: requested,
         resolvedLocale: resolution.resolvedLocale,
         fallbackPath: resolution.fallbackPath,
@@ -77,24 +70,13 @@ export function explainLocaleMessage(input) {
         diagnostics,
     };
 }
-/**
- * Diff two locales' catalogs.
- * @param {{
- * baseLocale: string,
- * targetLocale: string,
- * messages: Array<{ messageId: string, variants: Record<string, { template: string, params?: any[] }> }>,
- * }} input
- */
+/** Diff two locales' catalogs. */
 export function diffLocaleCatalogs(input) {
     const base = input.baseLocale;
     const target = input.targetLocale;
-    /** @type {any[]} */
     const missingInTarget = [];
-    /** @type {any[]} */
     const missingInBase = [];
-    /** @type {any[]} */
     const changed = [];
-    /** @type {any[]} */
     const paramMismatches = [];
     const ids = new Set();
     for (const m of input.messages || [])
@@ -138,13 +120,9 @@ export function diffLocaleCatalogs(input) {
 /**
  * Scan source for likely hardcoded UI text sinks (extract --check).
  * Does not auto-generate MessageIds.
- * @param {string} projectRoot
- * @param {{ check?: boolean }} [opts]
  */
 export function extractHardcodedText(projectRoot, opts = {}) {
-    /** @type {any[]} */
     const findings = [];
-    /** @type {any[]} */
     const diagnostics = [];
     const srcRoot = path.join(projectRoot, 'src');
     if (!fs.existsSync(srcRoot)) {
@@ -155,7 +133,6 @@ export function extractHardcodedText(projectRoot, opts = {}) {
             diagnostics: [],
         };
     }
-    /** @type {string[]} */
     const files = [];
     const walk = (dir) => {
         for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -248,14 +225,8 @@ export function extractHardcodedText(projectRoot, opts = {}) {
 /**
  * Pseudo-localize a source locale for layout/overflow testing.
  * Preserves ICU placeholders; marks provenance — never a production fallback.
- * @param {{
- * sourceLocale: string,
- * messages: Array<{ messageId: string, variants: Record<string, { template: string }> }>,
- * production?: boolean,
- * }} input
  */
 export function pseudoLocalizeCatalog(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     if (input.production) {
         diagnostics.push({
@@ -264,7 +235,6 @@ export function pseudoLocalizeCatalog(input) {
             message: 'pseudo locale must not be used as production fallback',
         });
     }
-    /** @type {Record<string, string>} */
     const catalog = {};
     for (const m of input.messages || []) {
         const src = m.variants?.[input.sourceLocale]?.template;
@@ -292,16 +262,8 @@ export function pseudoLocalizeCatalog(input) {
         diagnostics,
     };
 }
-/**
- * Cross-host conformance: same MessageId set + catalog hashes + formatter version.
- * @param {{
- * manifest: any,
- * messages: any[],
- * routeIds?: string[],
- * }} input
- */
+/** Cross-host conformance: same MessageId set + catalog hashes + formatter version. */
 export function checkLocaleConformance(input) {
-    /** @type {any[]} */
     const diagnostics = [];
     const supported = (input.manifest?.locales || []).map((l) => l.id);
     const defaultLocale = input.manifest?.defaultLocale;

package/dist/log.d.ts

@@ -1,19 +1,26 @@
 /**
- * Unified CLI logging / diagnostics .
+ * Unified CLI logging / diagnostics via `@vmz/diagnostic` + product catalog.
  */
+export type DiagnosticLike = {
+    severity?: string;
+    path?: string;
+    message?: string;
+    code?: string;
+    args?: Record<string, string>;
+    span?: {
+        start: number;
+        end: number;
+    };
+};
 export declare const log: {
-    /** @param {...unknown} args */
-    info(...args: any[]): void;
-    /** @param {...unknown} args */
-    warn(...args: any[]): void;
-    /** @param {...unknown} args */
-    error(...args: any[]): void;
-    /** @param {{ severity: string, path?: string, message: string, code?: string }} d */
-    diagnostic(d: any): void;
-    /**
-     * @param {Array<{ severity: string, path?: string, message: string, code?: string }>} diagnostics
-     * @param {{ denyWarnings?: boolean }} [opts]
-     * @returns {number} failing count (errors, and warnings if denyWarnings)
-     */
-    diagnostics(diagnostics: any, opts?: {}): number;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    /** Localized framework error (`cli.err.*`). */
+    errorId(id: string, args?: Record<string, string>): void;
+    diagnostic(d: DiagnosticLike): void;
+    /** Failing count: errors, and warnings when `denyWarnings`. */
+    diagnostics(diagnostics: DiagnosticLike[] | null | undefined, opts?: {
+        denyWarnings?: boolean;
+    }): number;
 };

package/dist/log.js

@@ -1,41 +1,44 @@
-// @ts-nocheck
 /**
- * Unified CLI logging / diagnostics .
+ * Unified CLI logging / diagnostics via `@vmz/diagnostic` + product catalog.
  */
-/** @param {string} level */
+import { formatDiagnostic } from '@vmz/diagnostic';
+import { loadCliCatalog, resolveVmzLocale, vmzCliLocalize } from './cli-localize.js';
 function stamp(level) {
     return `vmz ${level}`;
 }
 export const log = {
-    /** @param {...unknown} args */
     info(...args) {
         console.error(stamp('info'), ...args);
     },
-    /** @param {...unknown} args */
     warn(...args) {
         console.error(stamp('warn'), ...args);
     },
-    /** @param {...unknown} args */
     error(...args) {
         console.error(stamp('error'), ...args);
     },
-    /** @param {{ severity: string, path?: string, message: string, code?: string }} d */
+    /** Localized framework error (`cli.err.*`). */
+    errorId(id, args) {
+        console.error(stamp('error'), vmzCliLocalize.t(id, args));
+    },
     diagnostic(d) {
-        const sev = d.severity || 'error';
-        const code = d.code ? `${d.code}: ` : '';
-        const loc = d.path ? ` (${d.path})` : '';
-        // Prefer `vmz warn|error CODE: message (path)` so locale warnings are visible, not silent.
-        if (sev === 'warning') {
-            console.error(`${stamp('warn')} ${code}${d.message}${loc}`);
-            return;
-        }
-        console.error(`${stamp(sev === 'error' ? 'error' : sev)} ${code}${d.path ? `${d.path}: ` : ''}${d.message}`);
+        const severity = d.severity === 'warning' || d.severity === 'advice' || d.severity === 'error' ? d.severity : 'error';
+        const code = d.code && String(d.code).length ? String(d.code) : 'diag.message';
+        const locale = resolveVmzLocale();
+        const catalog = loadCliCatalog(locale);
+        const line = formatDiagnostic({
+            path: d.path || '',
+            severity,
+            code,
+            args: d.args || (d.message ? { message: String(d.message) } : undefined),
+            message: d.message,
+            span: d.span,
+        }, {
+            locale,
+            catalog,
+        });
+        console.error(stamp(severity === 'warning' ? 'warn' : severity === 'error' ? 'error' : 'diag'), line);
     },
-    /**
-     * @param {Array<{ severity: string, path?: string, message: string, code?: string }>} diagnostics
-     * @param {{ denyWarnings?: boolean }} [opts]
-     * @returns {number} failing count (errors, and warnings if denyWarnings)
-     */
+    /** Failing count: errors, and warnings when `denyWarnings`. */
     diagnostics(diagnostics, opts = {}) {
         let failing = 0;
         for (const d of diagnostics ?? []) {