@cspeach/cli 1.1.18 → 1.1.19

package/dist/tools/fiori/smoke/assertions.js

@@ -1,3 +1,4 @@
+import { innerFailures } from './batch.js';
 // A failed HTTP response is only smoke-relevant when it is an OData call:
 // $metadata (model load), $batch (V4 read/write), or an entity-set request
 // under the gateway/odata4 path. An incidental non-OData 404 (favicon, a
@@ -8,34 +9,163 @@ const ODATA_URL = /\$metadata|\$batch|\/sap\/opu\/odata|\/odata4?\//i;
 // Dev-mode noise, not app defects (F-L2-12) — must not fail boot.
 const UNBUILT_DEV_404 = /(Component-preload\.js|resources\.json)/i;
 const LOAD_FAILURE = /(404|failed to load)/i;
-/** Boot check: the app loaded without throwing anything to the console. */
-export function checkBoot(consoleErrors) {
-    const real = consoleErrors.filter((e) => !(UNBUILT_DEV_404.test(e) && LOAD_FAILURE.test(e)));
-    const ok = real.length === 0;
+// F-5 (L1-2b): 404s are judged by the NETWORK response URL, never by console
+// text. Chrome's own "Failed to load resource" console line carries no URL, so
+// an allowlist over console text matches nothing (a correct app fails) — the
+// driver's failed-response list is the authority instead.
+const CHROME_LOAD_FAILURE = /^Failed to load resource: the server responded with a status of \d+/;
+/**
+ * The ONLY failed non-OData responses boot tolerates — each named, each a 404,
+ * each matched on the URL path. Anything else (a missing controller file, a
+ * missing BASE i18n bundle, any 5xx) fails boot. Never widen this to "all 404s".
+ */
+export const BOOT_ALLOWED_404 = [
+    // UI5's ResourceBundle walks the locale chain (i18n_en_US → i18n_en → i18n)
+    // and 404s on every locale file an app does not ship. The base bundle
+    // (i18n.properties, no locale suffix) is NOT covered.
+    // Locale shape: a two-letter lower-case language, optionally _ + a two-letter
+    // upper-case region (de, pt_BR). `_abc` or `_EN` is a base bundle's name, not a locale.
+    { name: 'i18n locale fallback', path: /\/[^/]+_[a-z]{2}(_[A-Z]{2})?\.properties$/ },
+    // `fiori run` serves an unbuilt app: no preload bundle, no resources.json (F-L2-12).
+    { name: 'unbuilt dev serve', path: /\/(Component-preload\.js|resources\.json)$/ },
+    // The browser asks for /favicon.ico on its own; no app file references it.
+    { name: 'browser favicon probe', path: /^\/favicon\.ico$/ },
+    // The FLP sandbox bootstrap (sap/ushell sandbox.js) probes this optional
+    // config file at a fixed path and carries on without it.
+    { name: 'FLP sandbox optional config', path: /^\/appconfig\/fioriSandboxConfig\.json$/ },
+];
+// UI5 logs future-deprecation notices (sync loading, bAsync:false) through
+// Log.error, so they arrive as console errors. They are not failures of the app.
+// Only UI5's own notice FORMS are matched — an error that merely contains the
+// word "deprecated" ("TypeError: deprecated.call is not a function") still fails.
+const UI5_DEPRECATION_FORMS = [
+    /\bis deprecated\. Please use\b/, // "Resolving a class in this fashion is deprecated. Please use …"
+    /\bshould always be called with bAsync:true\b/, // sap.ushell.Container.createRenderer()
+    /\bis created synchronously\. Synchronous instantiation is not allowed\b/, // sap/ushell renderer
+    // UI5 1.96 only: SAP's FE page templates set shortCutExists="true" on the Share
+    // macro (sap/fe/templates; gone by 1.108). Exactly this property — any other
+    // "ignored … not intended for public usage" still fails.
+    /\bProperty shortCutExists was ignored as it is not intended for public usage\b/,
+    // UI5 1.136: future-deprecation notice from sap.ui.mdc about SAP's own FE
+    // FilterBar / Table controls (their propertyInfo, not the app's).
+    /\[FUTURE FATAL\] PropertyInfo validation is disabled for control [^\s]+\. Migrate this control's propertyInfo\b/,
+    // UI5 1.136: FE's own table macro binds its context-menu Delete to command
+    // DeleteEntry::ContextMenu; SAP's app generator (fe writer 3.1.65) defines no
+    // commands, so every generated app logs this. Exactly this command.
+    /\bCommand 'DeleteEntry::ContextMenu' is not defined in component manifest\. No shortcut will be registered\b/,
+];
+const UI5_DEPRECATION = { test: (e) => UI5_DEPRECATION_FORMS.some((re) => re.test(e)) };
+function pathOf(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url.split('?')[0] ?? url;
+    }
+}
+function isAllowed404(r) {
+    return r.status === 404 && BOOT_ALLOWED_404.some((a) => a.path.test(pathOf(r.url)));
+}
+// CAP phase 1 (rehearsal 2026-09-25): a CAP project's server answers the
+// unbuilt preload's 404 with an HTML page and nosniff, so Chrome also logs that
+// it refused to run it. Exactly this line, exactly Component-preload.js, and only
+// when the network list shows that same URL answered an allowed 404 (F-5).
+const REFUSED_PRELOAD = /^Refused to execute script from '([^']+\/Component-preload\.js)' because its MIME type \('text\/html'\) is not executable, and strict MIME type checking is enabled\.$/;
+function isRefusedAllowedPreload(e, failedRequests) {
+    const url = REFUSED_PRELOAD.exec(e)?.[1];
+    return url !== undefined && failedRequests.some((r) => r.url === url && isAllowed404(r));
+}
+/**
+ * Boot check: no real console error, and no failed app-file request.
+ * `failedRequests` are the network responses >= 400; OData ones are left to the
+ * odata check (not counted twice).
+ */
+// Dry run 2026-09-25: the header read "Suppliers & Quality Certificates"
+// and every check was green. An HTML escape in the VISIBLE text is a defect.
+const SHOWN_ESCAPE = /&(amp|lt|gt|quot|apos|#\d{1,7}|#x[0-9a-fA-F]{1,6});/;
+/** The first visible line carrying an HTML escape, or undefined. */
+function escapedLine(visibleText) {
+    return visibleText.split(/\r?\n/).map((l) => l.trim()).find((l) => SHOWN_ESCAPE.test(l));
+}
+export function checkBoot(consoleErrors, failedRequests = [], visibleText) {
+    const real = consoleErrors.filter((e) => !CHROME_LOAD_FAILURE.test(e) &&
+        !UI5_DEPRECATION.test(e) &&
+        !(UNBUILT_DEV_404.test(e) && LOAD_FAILURE.test(e)) &&
+        !isRefusedAllowedPreload(e, failedRequests));
+    const badLoads = failedRequests.filter((r) => !ODATA_URL.test(r.url) && !isAllowed404(r));
+    const escaped = visibleText === undefined ? undefined : escapedLine(visibleText);
+    const ok = real.length === 0 && badLoads.length === 0 && escaped === undefined;
+    const parts = [];
+    if (escaped !== undefined)
+        parts.push(`HTML escape shown on screen: "${escaped.slice(0, 120)}"`);
+    if (real.length > 0)
+        parts.push(`${real.length} console error(s) during boot: ${real.slice(0, 3).join(' | ')}`);
+    if (badLoads.length > 0) {
+        parts.push(`${badLoads.length} failed app request(s): ${badLoads.slice(0, 5).map((r) => `${r.status} ${r.url}`).join(' | ')}`);
+    }
     return {
         name: 'boot',
         ok,
-        detail: ok
-            ? 'app booted with no console errors'
-            : `${real.length} console error(s) during boot: ${real.slice(0, 3).join(' | ')}`,
+        detail: ok ? 'app booted with no console errors and no failed app requests' : parts.join('; '),
     };
 }
-/** OData check: no 4xx/5xx on any $metadata / $batch / entity-set request. */
-export function checkOData(failedRequests) {
+/**
+ * OData check: no 4xx/5xx on any $metadata / $batch / entity-set request.
+ * F-2: FAILS when no OData request was observed at all — a check that judged
+ * zero requests proves nothing. `observed` is every response the driver saw
+ * (any status); `failedRequests` are the ones >= 400.
+ * L1-5a: `inner` are the requests INSIDE the recorded `$batch` bodies. A 200
+ * `$batch` whose Activate part is 400 fails here. When every inner part is fine
+ * the result is exactly what it was without them.
+ * CAP phase 1: `unanswered` are requests the browser sent that never got a
+ * response. With no OData response at all, unanswered OData requests are named —
+ * a server asking for a login (CAP's mocked auth) holds them open.
+ */
+export function checkOData(failedRequests, observed, inner = [], unanswered = []) {
+    const seen = observed.filter((r) => ODATA_URL.test(r.url));
+    const held = unanswered.filter((u) => ODATA_URL.test(u));
+    if (seen.length === 0 && held.length > 0) {
+        return {
+            name: 'odata',
+            ok: false,
+            detail: `no OData response arrived — ${held.length} OData request(s) started but never answered: ${held.slice(0, 3).join(' | ')}. ` +
+                'A server that asks for a login holds them open — for a CAP service with @requires, pass capUser.',
+        };
+    }
+    if (seen.length === 0) {
+        return {
+            name: 'odata',
+            ok: false,
+            detail: 'no OData request was observed (no $metadata, $batch or entity-set call) — nothing to judge',
+        };
+    }
     const bad = failedRequests.filter((r) => ODATA_URL.test(r.url));
-    const ok = bad.length === 0;
+    const badInner = innerFailures(inner);
+    const ok = bad.length === 0 && badInner.length === 0;
+    const parts = [];
+    if (bad.length > 0)
+        parts.push(`${bad.length} failed OData request(s): ${bad.map((r) => `${r.status} ${r.url}`).join(' | ')}`);
+    if (badInner.length > 0) {
+        parts.push(`${badInner.length} failed inner $batch request(s): ` +
+            badInner
+                // The query ($select/$expand) is noise in a failure line; the path names the request.
+                .map((p) => `${p.status} ${p.method} ${p.url.split('?')[0]}${p.errorMessage ? ` — ${p.errorMessage}` : ''}`)
+                .join(' | '));
+    }
     return {
         name: 'odata',
         ok,
-        detail: ok
-            ? 'no failed OData requests'
-            : `${bad.length} failed OData request(s): ${bad.map((r) => `${r.status} ${r.url}`).join(' | ')}`,
+        detail: ok ? `${seen.length} OData request(s) observed, none failed` : parts.join('; '),
     };
 }
+/** F-8: UI5 hyphenates header text with U+00AD and may join words with U+00A0. */
+export function normaliseHeader(text) {
+    return text.replace(/\u00ad/g, '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim().toLowerCase();
+}
 /** Columns check: every expected column is present in the header texts (case-insensitive). */
 export function checkColumns(headerTexts, expectedColumns) {
-    const present = new Set(headerTexts.map((h) => h.trim().toLowerCase()));
-    const missing = expectedColumns.filter((c) => !present.has(c.trim().toLowerCase()));
+    const present = new Set(headerTexts.map(normaliseHeader));
+    const missing = expectedColumns.filter((c) => !present.has(normaliseHeader(c)));
     const ok = missing.length === 0;
     return {
         name: 'columns',
@@ -56,24 +186,31 @@ export function checkRows(rowCount, allowEmptyRows) {
     return { name: 'rows', ok: false, detail: '0 rows rendered and allowEmptyRows was not set' };
 }
 /**
- * Exercise check: every exercise ran without throwing and without emitting a new
- * console error. A single throwing handler or a single new console error fails the
- * whole smoke (dynamic A4). Vacuously passes on an empty result set.
+ * Exercise check: every exercise ran without throwing, without a new console
+ * error and without an uncaught page error (F-6). Any one fails the whole smoke
+ * (dynamic A4). Vacuously passes on an empty result set.
  */
 export function checkExercise(results) {
-    const failures = results.filter((r) => r.threw !== undefined || r.newConsoleErrors.length > 0);
+    const pageErrs = (r) => r.newPageErrors ?? [];
+    const failures = results.filter((r) => r.threw !== undefined || r.newConsoleErrors.length > 0 || pageErrs(r).length > 0);
     const ok = failures.length === 0;
     return {
         name: 'exercises',
         ok,
         detail: ok
-            ? `all ${results.length} exercise(s) ran without new console errors`
+            ? `all ${results.length} exercise(s) ran without new console or page errors`
             : failures
                 .map((f) => {
-                const reason = f.threw !== undefined
-                    ? `threw: ${f.threw}`
-                    : `${f.newConsoleErrors.length} new console error(s): ${f.newConsoleErrors.slice(0, 2).join(' | ')}`;
-                return `${f.kind} ${f.label} — ${reason}`;
+                const reasons = [];
+                if (f.threw !== undefined)
+                    reasons.push(`threw: ${f.threw}`);
+                if (pageErrs(f).length > 0) {
+                    reasons.push(`${pageErrs(f).length} uncaught page error(s): ${pageErrs(f).slice(0, 2).join(' | ')}`);
+                }
+                if (f.newConsoleErrors.length > 0) {
+                    reasons.push(`${f.newConsoleErrors.length} new console error(s): ${f.newConsoleErrors.slice(0, 2).join(' | ')}`);
+                }
+                return `${f.kind} ${f.label} — ${reasons.join('; ')}`;
             })
                 .join('; '),
     };

package/dist/tools/fiori/smoke/audit-columns.js

@@ -0,0 +1,21 @@
+/**
+ * `UI.LineItem`, in order: every DataField-like entry that shows a property.
+ * Label = the DataField's own Label (it wins in Fiori), else the property's
+ * Common.Label. Action / annotation columns are excluded — they carry no
+ * property. An unlabelled column is KEPT with `label: undefined` so the
+ * `labels` check can fail on it instead of silently dropping it.
+ */
+export function deriveExpectedColumns(audit) {
+    const byName = new Map(audit.properties.map((p) => [p.name, p]));
+    const out = [];
+    for (const col of [...audit.lineItem].sort((a, b) => a.position - b.position)) {
+        if (col.kind !== 'DataField' && col.kind !== 'DataFieldWithUrl')
+            continue;
+        if (!col.property)
+            continue;
+        const p = byName.get(col.property);
+        const common = p && p.labelSource !== 'none' ? p.label : undefined;
+        out.push({ property: col.property, label: col.label ?? common });
+    }
+    return out;
+}

package/dist/tools/fiori/smoke/batch.js

@@ -0,0 +1,273 @@
+// cspeach-cli/src/tools/fiori/smoke/batch.ts
+//
+// L1-5a — a PURE parser for OData `$batch` bodies.
+//
+// Fiori Elements V4 sends every read and every draft action inside `$batch`.
+// The OUTER response is 200 even when an inner PATCH or Activate is 400 / 412 /
+// 428, so a smoke that judges outer statuses reads a failed activation as green
+// (design §3.3, review F-4). This module turns a recorded request/response pair
+// into one row per inner request: `{method, url, status, errorMessage}`.
+//
+// Both wire formats:
+//  - `multipart/mixed` (OData 4.01 Part 1 §11.7.7): parts are
+//    `application/http` messages or nested `multipart/mixed` change sets. A
+//    FAILED change set is answered by ONE part — every change in it takes that
+//    failure.
+//  - JSON (OData JSON Format 4.01 §19): `{requests:[…]}` / `{responses:[…]}`,
+//    paired by `id`; a failed atomicity group may be answered once, by the
+//    group id.
+//
+// No I/O, no browser. A request that got no response part is a FAILURE
+// (status 0), never a silent pass.
+export class BatchParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'BatchParseError';
+    }
+}
+const isJson = (ct) => /^\s*application\/json/i.test(ct);
+function boundaryOf(contentType) {
+    const m = /boundary\s*=\s*(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+    const b = m?.[1] ?? m?.[2];
+    if (!b)
+        throw new BatchParseError(`no multipart boundary in content type "${contentType}"`);
+    return b;
+}
+/** Split a head/body at the first blank line (CRLF or LF). */
+function splitHead(text) {
+    const m = /\r?\n\r?\n/.exec(text);
+    if (!m)
+        return { head: text, body: '' };
+    return { head: text.slice(0, m.index), body: text.slice(m.index + m[0].length) };
+}
+function parseHeaders(head) {
+    const out = {};
+    for (const line of head.split(/\r?\n/)) {
+        const i = line.indexOf(':');
+        if (i <= 0)
+            continue;
+        out[line.slice(0, i).trim().toLowerCase()] = line.slice(i + 1).trim();
+    }
+    return out;
+}
+/** The parts between `--boundary` delimiters; preamble and epilogue dropped. */
+function splitMultipart(body, boundary) {
+    const delim = `--${boundary}`;
+    const lines = body.split(/\r?\n/);
+    const parts = [];
+    let current = null;
+    let closed = false;
+    let sawDelimiter = false;
+    for (const line of lines) {
+        const t = line.trimEnd();
+        if (t === delim || t === `${delim}--`) {
+            sawDelimiter = true;
+            if (current)
+                parts.push(current);
+            if (t === `${delim}--`) {
+                closed = true;
+                current = null;
+                break;
+            }
+            current = [];
+            continue;
+        }
+        if (current)
+            current.push(line);
+    }
+    if (!sawDelimiter)
+        throw new BatchParseError(`multipart boundary "${boundary}" does not occur in the body`);
+    if (current && !closed)
+        parts.push(current);
+    return parts.map((p) => {
+        const { head, body: rest } = splitHead(p.join('\r\n'));
+        return { headers: parseHeaders(head), body: rest };
+    });
+}
+function isChangeSet(part) {
+    return /^multipart\/mixed/i.test(part.headers['content-type'] ?? '');
+}
+function requestLineOf(part) {
+    const first = part.body.replace(/^\s+/, '').split(/\r?\n/)[0] ?? '';
+    const m = /^([A-Z]+)\s+(\S+)(?:\s+HTTP\/\d(?:\.\d)?)?\s*$/.exec(first);
+    if (!m)
+        throw new BatchParseError(`not an HTTP request line: "${first.slice(0, 120)}"`);
+    return { method: m[1], url: m[2] };
+}
+/** A human message from an error body or the sap-messages header, else the status line. */
+function errorMessageOf(status, reason, headers, body) {
+    if (status < 400)
+        return undefined;
+    const fromJson = (v) => {
+        if (!v || typeof v !== 'object')
+            return undefined;
+        const o = v;
+        const err = (o.error && typeof o.error === 'object' ? o.error : o);
+        const msg = err.message;
+        if (typeof msg === 'string' && msg)
+            return msg;
+        if (msg && typeof msg === 'object' && typeof msg.value === 'string') {
+            return msg.value;
+        }
+        return undefined;
+    };
+    const trimmed = body.trim();
+    if (trimmed.startsWith('{')) {
+        try {
+            const m = fromJson(JSON.parse(trimmed));
+            if (m)
+                return m;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const sapMessages = headers['sap-messages'];
+    if (sapMessages) {
+        try {
+            const parsed = JSON.parse(sapMessages);
+            const list = Array.isArray(parsed) ? parsed : [parsed];
+            const msgs = list.map((x) => (x && typeof x.message === 'string' ? x.message : '')).filter((x) => x);
+            if (msgs.length > 0)
+                return msgs.join(' | ');
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    return `${status}${reason ? ` ${reason}` : ''}`;
+}
+function responseLineOf(part, group) {
+    const { head, body } = splitHead(part.body.replace(/^\s+/, ''));
+    const [statusLine = '', ...headerLines] = head.split(/\r?\n/);
+    const m = /^HTTP\/\d(?:\.\d)?\s+(\d{3})\s*(.*)$/.exec(statusLine.trim());
+    if (!m)
+        throw new BatchParseError(`not an HTTP status line: "${statusLine.slice(0, 120)}"`);
+    const status = Number(m[1]);
+    const headers = parseHeaders(headerLines.join('\n'));
+    const errorMessage = errorMessageOf(status, m[2].trim(), headers, body);
+    const id = part.headers['content-id'];
+    return { status, group, ...(id ? { id } : {}), ...(errorMessage ? { errorMessage } : {}) };
+}
+function parseJson(body, key) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        throw new BatchParseError(`JSON $batch body is not JSON`);
+    }
+    const list = parsed?.[key];
+    if (!Array.isArray(list))
+        throw new BatchParseError(`JSON $batch body has no "${key}" array`);
+    return list;
+}
+/** One line per inner request, in order. */
+export function parseBatchRequest(body, contentType) {
+    if (isJson(contentType)) {
+        return parseJson(body, 'requests').map((r, i) => ({
+            method: String(r.method ?? '').toUpperCase(),
+            url: String(r.url ?? ''),
+            ...(r.id !== undefined ? { id: String(r.id) } : {}),
+            group: r.atomicityGroup !== undefined ? String(r.atomicityGroup) : `#${i}`,
+        }));
+    }
+    const out = [];
+    splitMultipart(body, boundaryOf(contentType)).forEach((part, group) => {
+        const members = isChangeSet(part) ? splitMultipart(part.body, boundaryOf(part.headers['content-type'])) : [part];
+        for (const m of members) {
+            const id = m.headers['content-id'];
+            out.push({ ...requestLineOf(m), ...(id ? { id } : {}), group });
+        }
+    });
+    return out;
+}
+/** One line per inner response part, in order (a failed change set is ONE line). */
+export function parseBatchResponse(body, contentType) {
+    if (isJson(contentType)) {
+        return parseJson(body, 'responses').map((r, i) => {
+            const status = Number(r.status ?? 0);
+            const bodyText = r.body === undefined ? '' : typeof r.body === 'string' ? r.body : JSON.stringify(r.body);
+            const headers = {};
+            for (const [k, v] of Object.entries(r.headers ?? {}))
+                headers[k.toLowerCase()] = String(v);
+            const errorMessage = errorMessageOf(status, '', headers, bodyText);
+            return {
+                status,
+                ...(r.id !== undefined ? { id: String(r.id) } : {}),
+                group: r.atomicityGroup !== undefined ? String(r.atomicityGroup) : `#${i}`,
+                ...(errorMessage ? { errorMessage } : {}),
+            };
+        });
+    }
+    const out = [];
+    splitMultipart(body, boundaryOf(contentType)).forEach((part, group) => {
+        if (isChangeSet(part)) {
+            for (const m of splitMultipart(part.body, boundaryOf(part.headers['content-type'])))
+                out.push(responseLineOf(m, group));
+        }
+        else {
+            out.push(responseLineOf(part, group));
+        }
+    });
+    return out;
+}
+const NO_RESPONSE = 'no response part for this request';
+function part(req, res) {
+    if (!res)
+        return { method: req.method, url: req.url, status: 0, errorMessage: NO_RESPONSE };
+    return {
+        method: req.method,
+        url: req.url,
+        status: res.status,
+        ...(res.errorMessage !== undefined ? { errorMessage: res.errorMessage } : {}),
+    };
+}
+/**
+ * Join the requests with their responses.
+ * Multipart: top-level group by group, in order; inside a group by position,
+ * and a group answered by ONE part (a failed change set) gives every member
+ * that answer. JSON: by id; a request with no answer of its own takes the
+ * answer given to its atomicity group.
+ */
+export function pairBatch(ex) {
+    const reqs = parseBatchRequest(ex.requestBody, ex.requestContentType);
+    const resps = parseBatchResponse(ex.responseBody, ex.responseContentType);
+    if (isJson(ex.requestContentType)) {
+        const byId = new Map(resps.filter((r) => r.id !== undefined).map((r) => [r.id, r]));
+        return reqs.map((q) => {
+            const own = q.id !== undefined ? byId.get(q.id) : undefined;
+            const groupAnswer = typeof q.group === 'string' && !q.group.startsWith('#')
+                ? resps.find((r) => r.group === q.group && (r.id === undefined || r.id === q.group))
+                : undefined;
+            return part(q, own ?? groupAnswer);
+        });
+    }
+    const groups = new Map();
+    for (const q of reqs)
+        groups.set(q.group, [...(groups.get(q.group) ?? []), q]);
+    const respGroups = new Map();
+    for (const r of resps)
+        respGroups.set(r.group, [...(respGroups.get(r.group) ?? []), r]);
+    // Response groups are matched to request groups by ORDER, not by index: a
+    // failed change set shrinks to one part but keeps its place.
+    const reqGroupKeys = [...groups.keys()];
+    const respGroupKeys = [...respGroups.keys()];
+    const out = [];
+    reqGroupKeys.forEach((gk, gi) => {
+        const members = groups.get(gk);
+        const answers = respGroups.get(respGroupKeys[gi]) ?? [];
+        if (members.length > 1 && answers.length === 1) {
+            for (const m of members)
+                out.push(part(m, answers[0]));
+        }
+        else {
+            members.forEach((m, i) => out.push(part(m, answers[i])));
+        }
+    });
+    return out;
+}
+/** The inner parts that failed: status >= 400, or no response at all. */
+export function innerFailures(parts) {
+    return parts.filter((p) => p.status === 0 || p.status >= 400);
+}