arc-1 0.6.10 → 0.7.0

package/dist/adt/diagnostics.js

@@ -9,6 +9,11 @@
  */
 import { checkOperation, OperationType } from './safety.js';
 import { findDeepNodes, parseXml } from './xml-parser.js';
+// ─── Short Dumps ────────────────────────────────────────────────────
+const DEFAULT_DUMP_MAX_RESULTS = 50;
+const DEFAULT_SYSTEM_MESSAGE_MAX_RESULTS = 50;
+const DEFAULT_GATEWAY_ERROR_MAX_RESULTS = 50;
+const MAX_RESULTS_CAP = 200;
 /**
  * List ABAP short dumps (ST22 equivalent).
  *
@@ -17,14 +22,7 @@ import { findDeepNodes, parseXml } from './xml-parser.js';
  */
 export async function listDumps(http, safety, options) {
     checkOperation(safety, OperationType.Read, 'ListDumps');
-    const params = [];
-    if (options?.maxResults) {
-        params.push(`$top=${options.maxResults}`);
-    }
-    if (options?.user) {
-        params.push(`$query=${encodeURIComponent(`and(equals(user,${options.user}))`)}`);
-    }
-    const queryString = params.length > 0 ? `?${params.join('&')}` : '';
+    const queryString = buildFeedQueryString(options, DEFAULT_DUMP_MAX_RESULTS, 'user');
     const resp = await http.get(`/sap/bc/adt/runtime/dumps${queryString}`, {
         Accept: 'application/atom+xml;type=feed',
     });
@@ -52,6 +50,55 @@ export async function getDump(http, safety, dumpId) {
     ]);
     return parseDumpDetail(xmlResp.body, textResp.body, dumpId);
 }
+// ─── System Messages + Gateway Errors ──────────────────────────────
+/**
+ * List SM02 system messages.
+ *
+ * Endpoint: GET /sap/bc/adt/runtime/systemmessages
+ * Returns an Atom feed with system message entries.
+ */
+export async function listSystemMessages(http, safety, options) {
+    checkOperation(safety, OperationType.Read, 'ListSystemMessages');
+    const queryString = buildFeedQueryString(options, DEFAULT_SYSTEM_MESSAGE_MAX_RESULTS, 'user');
+    const resp = await http.get(`/sap/bc/adt/runtime/systemmessages${queryString}`, {
+        Accept: 'application/atom+xml;type=feed',
+    });
+    return parseSystemMessages(resp.body);
+}
+/**
+ * List SAP Gateway error log entries (/IWFND/ERROR_LOG).
+ *
+ * Endpoint: GET /sap/bc/adt/gw/errorlog
+ * Returns an Atom feed with gateway error entries.
+ */
+export async function listGatewayErrors(http, safety, options) {
+    checkOperation(safety, OperationType.Read, 'ListGatewayErrors');
+    const queryString = buildFeedQueryString(options, DEFAULT_GATEWAY_ERROR_MAX_RESULTS, 'username');
+    const resp = await http.get(`/sap/bc/adt/gw/errorlog${queryString}`, {
+        Accept: 'application/atom+xml;type=feed',
+    });
+    return parseGatewayErrors(resp.body);
+}
+/**
+ * Read one gateway error detail payload.
+ *
+ * The ADT /sap/bc/adt/gw/errorlog/{type}/{id} endpoint returns an HTML
+ * fragment (not XML), so the parser extracts tabular values from known
+ * section anchors (#HEADER, #SERVICE, #CONTEXT, #SOURCE, #STACK).
+ *
+ * Supports either:
+ * - full/relative ADT detail URL from a feed entry,
+ * - id of the form "{errorType}/{transactionId}" (as emitted by the feed), or
+ * - transaction id + errorType parameters.
+ */
+export async function getGatewayErrorDetail(http, safety, params) {
+    checkOperation(safety, OperationType.Read, 'GetGatewayErrorDetail');
+    const path = resolveGatewayErrorDetailPath(params);
+    const resp = await http.get(path, {
+        Accept: 'text/html, application/xhtml+xml, application/xml;q=0.5',
+    });
+    return parseGatewayErrorDetail(resp.body);
+}
 // ─── ABAP Traces ────────────────────────────────────────────────────
 /**
  * List ABAP profiler trace files.
@@ -106,43 +153,22 @@ export async function getTraceDbAccesses(http, safety, traceId) {
 /**
  * Parse dump listing Atom feed.
  *
- * Each atom:entry contains:
- * - atom:author/atom:name → user
- * - atom:category term="..." label="ABAP runtime error" → error type
- * - atom:category term="..." label="Terminated ABAP program" → program
- * - atom:published → timestamp
- * - atom:link rel="self" href → contains dump ID path
+ * Robust against localized category labels and missing self links.
  */
 export function parseDumpList(xml) {
     const parsed = parseXml(xml);
     const entryNodes = findDeepNodes(parsed, 'entry');
     return entryNodes
         .map((entry) => {
-        // Author name
-        const author = entry.author;
+        const author = toRecordArray(entry.author)[0];
         const user = String(author?.name ?? '');
-        // Categories: may be single object or array
-        const rawCat = entry.category;
-        const categories = Array.isArray(rawCat) ? rawCat : rawCat ? [rawCat] : [];
-        let error = '';
-        let program = '';
-        for (const cat of categories) {
-            const label = String(cat['@_label'] ?? '');
-            if (label === 'ABAP runtime error')
-                error = String(cat['@_term'] ?? '');
-            if (label === 'Terminated ABAP program')
-                program = String(cat['@_term'] ?? '');
-        }
-        const timestamp = String(entry.published ?? '');
-        // Extract dump ID from self link href
-        const links = Array.isArray(entry.link) ? entry.link : entry.link ? [entry.link] : [];
-        const selfLink = links.find((l) => String(l['@_rel'] ?? '') === 'self');
-        const href = String(selfLink?.['@_href'] ?? '');
-        const dumpMatch = href.match(/\/sap\/bc\/adt\/runtime\/dump\/([^"]*)/);
-        const id = dumpMatch?.[1] || '';
+        const categories = toRecordArray(entry.category);
+        const { error, program } = parseDumpCategories(categories);
+        const timestamp = String(entry.published ?? entry.updated ?? '');
+        const id = extractDumpId(entry);
         return { id, timestamp, user, error, program };
     })
-        .filter((e) => e.id);
+        .filter((entry) => entry.id.length > 0);
 }
 /**
  * Parse dump detail XML metadata + formatted text.
@@ -171,7 +197,11 @@ export function parseDumpDetail(xml, formattedText, dumpId) {
         name: String(ch['@_name'] ?? ''),
         title: String(ch['@_title'] ?? ''),
         category: String(ch['@_category'] ?? ''),
+        line: safePositiveInt(ch['@_line']),
+        chapterOrder: safePositiveInt(ch['@_chapterOrder']),
+        categoryOrder: safePositiveInt(ch['@_categoryOrder']),
     }));
+    const sections = splitDumpSections(formattedText, chapters);
     return {
         id: dumpId,
         error,
@@ -181,9 +211,200 @@ export function parseDumpDetail(xml, formattedText, dumpId) {
         timestamp,
         chapters,
         formattedText,
+        sections,
         terminationUri,
     };
 }
+/**
+ * Parse system message feed.
+ */
+export function parseSystemMessages(xml) {
+    const parsed = parseXml(xml);
+    const entryNodes = findDeepNodes(parsed, 'entry');
+    return entryNodes
+        .map((entry) => {
+        const links = toRecordArray(entry.link);
+        const selfHref = extractSelfLinkHref(links);
+        const categories = toRecordArray(entry.category);
+        const severity = String(categories[0]?.['@_term'] ?? '');
+        const contentNode = toRecordArray(entry.content)[0];
+        const summaryNode = toRecordArray(entry.summary)[0];
+        return {
+            id: String(entry.id ?? ''),
+            title: String(entry.title ?? ''),
+            text: String(contentNode?.['#text'] ?? summaryNode?.['#text'] ?? entry.summary ?? ''),
+            severity,
+            validFrom: String(entry['@_validFrom'] ?? entry.validFrom ?? entry.updated ?? entry.published ?? ''),
+            validTo: String(entry['@_validTo'] ?? entry.validTo ?? ''),
+            createdBy: String(toRecordArray(entry.author)[0]?.name ?? ''),
+            timestamp: String(entry.updated ?? entry.published ?? ''),
+            detailUrl: selfHref || undefined,
+        };
+    })
+        .filter((entry) => entry.id.length > 0 || entry.title.length > 0 || entry.text.length > 0);
+}
+/**
+ * Parse gateway error log feed.
+ *
+ * Real ADT feed entries encode the error class + transaction id in
+ * <atom:id>ErrorClass/transactionId</atom:id>, the full label in
+ * <atom:title>Type: short text</atom:title>, and the structured payload in
+ * the <atom:summary type="html"> HTML blob (same content the detail
+ * endpoint returns). No <atom:category> or <atom:link rel="self"> is
+ * emitted, so the parser derives the detail URL from the atom:id and
+ * extracts header fields from the summary HTML when available.
+ */
+export function parseGatewayErrors(xml) {
+    const parsed = parseXml(xml);
+    const entryNodes = findDeepNodes(parsed, 'entry');
+    return entryNodes
+        .map((entry) => {
+        const atomId = String(entry.id ?? '');
+        const rawTitle = String(entry.title ?? '').trim();
+        const summaryHtml = extractEntrySummaryHtml(entry);
+        const { errorType: idErrorType, transactionId: idTransactionId } = splitGatewayAtomId(atomId);
+        const links = toRecordArray(entry.link);
+        const selfHref = extractSelfLinkHref(links);
+        // Legacy / forward-compat: some feeds may expose <atom:category term="Frontend Error"/>
+        const categoryTerm = String(toRecordArray(entry.category)[0]?.['@_term'] ?? '').trim();
+        // Multi-source derivation so one missing field does not lose everything.
+        const summaryType = extractHtmlHeaderValue(summaryHtml, 'Type');
+        const titleType = rawTitle.includes(':') ? rawTitle.slice(0, rawTitle.indexOf(':')).trim() : '';
+        const typeFromId = splitCamelCase(idErrorType);
+        const type = summaryType || categoryTerm || titleType || typeFromId;
+        const summaryShortText = extractHtmlHeaderValue(summaryHtml, 'Short Text');
+        const titleShortText = rawTitle.includes(':') ? rawTitle.slice(rawTitle.indexOf(':') + 1).trim() : rawTitle;
+        const shortText = summaryShortText || titleShortText;
+        const summaryTransactionId = extractTransactionIdFromHtml(summaryHtml);
+        const transactionId = summaryTransactionId || idTransactionId || extractTailId(atomId);
+        const detailUrl = selfHref ||
+            (idErrorType && idTransactionId
+                ? `/sap/bc/adt/gw/errorlog/${encodeURIComponent(idErrorType)}/${encodeURIComponent(idTransactionId)}`
+                : '');
+        return {
+            type,
+            shortText,
+            transactionId,
+            dateTime: String(entry.updated ?? entry.published ?? ''),
+            username: String(toRecordArray(entry.author)[0]?.name ?? ''),
+            detailUrl,
+            package: getOptionalString(entry, ['@_package', 'package']) ??
+                (extractHtmlHeaderValue(summaryHtml, 'Package') || undefined),
+            applicationComponent: getOptionalString(entry, ['@_applicationComponent', 'applicationComponent']) ??
+                (extractHtmlHeaderValue(summaryHtml, 'Application Component') || undefined),
+            client: getOptionalString(entry, ['@_client', 'client']) ??
+                (extractHtmlHeaderValue(summaryHtml, 'Client') || undefined),
+            requestKind: getOptionalString(entry, ['@_requestKind', 'requestKind']) ??
+                (extractHtmlHeaderValue(summaryHtml, 'Request Kind') || undefined),
+        };
+    })
+        .filter((entry) => entry.transactionId.length > 0 || entry.detailUrl.length > 0);
+}
+/**
+ * Parse gateway error detail payload.
+ *
+ * Accepts either the legacy XML envelope (with <errorEntry>) if the backend
+ * ever returns one, or the HTML fragment that the real /sap/bc/adt/gw/errorlog
+ * endpoint returns. Missing sections fall back to empty values rather than
+ * throwing, so callers can still surface partial data to the LLM.
+ */
+export function parseGatewayErrorDetail(payload) {
+    const trimmed = (payload ?? '').trim();
+    const looksLikeXmlEnvelope = trimmed.startsWith('<?xml') || /<errorEntry[\s>]/.test(trimmed);
+    if (looksLikeXmlEnvelope) {
+        const xmlResult = parseGatewayErrorDetailXml(trimmed);
+        if (xmlResult)
+            return xmlResult;
+    }
+    return parseGatewayErrorDetailHtml(trimmed);
+}
+function parseGatewayErrorDetailXml(xml) {
+    try {
+        const parsed = parseXml(xml);
+        const errorNode = findDeepNodes(parsed, 'errorEntry')[0];
+        if (!errorNode)
+            return undefined;
+        const callStackEntries = parseGatewayCallStack(errorNode);
+        const sourceLines = parseGatewaySourceLines(errorNode);
+        const exceptions = parseGatewayExceptions(errorNode);
+        const serviceInfoNode = toRecordArray(errorNode.serviceInfo)[0];
+        const errorContextNode = toRecordArray(errorNode.errorContext)[0];
+        const sourceCodeNode = toRecordArray(errorNode.sourceCode)[0];
+        const serviceInfo = {
+            namespace: String(serviceInfoNode?.['@_namespace'] ?? ''),
+            serviceName: String(serviceInfoNode?.['@_serviceName'] ?? ''),
+            serviceVersion: String(serviceInfoNode?.['@_serviceVersion'] ?? ''),
+            groupId: String(serviceInfoNode?.['@_groupId'] ?? ''),
+            serviceRepository: String(serviceInfoNode?.['@_serviceRepository'] ?? ''),
+            destination: String(serviceInfoNode?.['@_destination'] ?? ''),
+        };
+        return {
+            type: String(errorNode['@_type'] ?? ''),
+            shortText: String(errorNode.shortText ?? ''),
+            transactionId: String(errorNode.transactionId ?? ''),
+            package: String(errorNode.package ?? ''),
+            applicationComponent: String(errorNode.applicationComponent ?? ''),
+            dateTime: String(errorNode.dateTime ?? ''),
+            username: String(errorNode.username ?? ''),
+            client: String(errorNode.client ?? ''),
+            requestKind: String(errorNode.requestKind ?? ''),
+            serviceInfo,
+            errorContext: {
+                errorInfo: String(errorContextNode?.errorInfo ?? ''),
+                resolution: {},
+                exceptions,
+            },
+            sourceCode: {
+                lines: sourceLines,
+                errorLine: safePositiveInt(sourceCodeNode?.['@_errorLine']),
+            },
+            callStack: callStackEntries,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseGatewayErrorDetailHtml(html) {
+    const header = extractHtmlSection(html, 'HEADER');
+    const service = extractHtmlSection(html, 'SERVICE');
+    const context = extractHtmlSection(html, 'CONTEXT');
+    const source = extractHtmlSection(html, 'SOURCE');
+    const stack = extractHtmlSection(html, 'STACK');
+    const resolution = {};
+    const sapNote = extractHtmlHeaderValue(context, 'SAP_NOTE');
+    if (sapNote)
+        resolution.sapNote = sapNote;
+    const sapNoteLink = extractHtmlHeaderValue(context, 'LINK_TO_SAP_NOTE');
+    if (sapNoteLink)
+        resolution.linkToSapNote = sapNoteLink;
+    return {
+        type: extractHtmlHeaderValue(header, 'Type'),
+        shortText: extractHtmlHeaderValue(header, 'Short Text'),
+        transactionId: extractTransactionIdFromHtml(header),
+        package: extractHtmlHeaderValue(header, 'Package'),
+        applicationComponent: extractHtmlHeaderValue(header, 'Application Component'),
+        dateTime: extractHtmlHeaderValue(header, 'Date/Time'),
+        username: extractHtmlHeaderValue(header, 'Username'),
+        client: extractHtmlHeaderValue(header, 'Client'),
+        requestKind: extractHtmlHeaderValue(header, 'Request Kind'),
+        serviceInfo: {
+            namespace: extractHtmlHeaderValue(service, 'Service Namespace'),
+            serviceName: extractHtmlHeaderValue(service, 'Service Name'),
+            serviceVersion: extractHtmlHeaderValue(service, 'Service Version'),
+            groupId: extractHtmlHeaderValue(service, 'Group ID'),
+            serviceRepository: extractHtmlHeaderValue(service, 'Service Repository'),
+            destination: extractHtmlHeaderValue(service, 'Destination'),
+        },
+        errorContext: {
+            errorInfo: extractHtmlHeaderValue(context, 'ERROR_INFO'),
+            resolution,
+            exceptions: extractGatewayExceptionsFromHtml(context),
+        },
+        sourceCode: extractGatewaySourceFromHtml(source),
+        callStack: extractGatewayCallStackFromHtml(stack),
+    };
+}
 /**
  * Parse trace listing Atom feed.
  *
@@ -267,4 +488,441 @@ export function parseTraceDbAccesses(xml) {
         accessTime: Number(node['@_accessTime'] ?? 0),
     }));
 }
+// ─── Helpers ────────────────────────────────────────────────────────
+function buildFeedQueryString(options, defaultMaxResults, userAttribute) {
+    const params = [];
+    const maxResults = clampMaxResults(options?.maxResults, defaultMaxResults);
+    params.push(`$top=${maxResults}`);
+    const user = String(options?.user ?? '').trim();
+    if (user) {
+        params.push(`$query=${encodeURIComponent(`and(equals(${userAttribute},${user}))`)}`);
+    }
+    const from = String(options?.from ?? '').trim();
+    if (from)
+        params.push(`from=${encodeURIComponent(from)}`);
+    const to = String(options?.to ?? '').trim();
+    if (to)
+        params.push(`to=${encodeURIComponent(to)}`);
+    return params.length > 0 ? `?${params.join('&')}` : '';
+}
+function clampMaxResults(maxResults, fallback) {
+    if (!Number.isFinite(maxResults))
+        return fallback;
+    return Math.max(1, Math.min(MAX_RESULTS_CAP, Math.trunc(maxResults)));
+}
+function toRecordArray(value) {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => Boolean(entry) && typeof entry === 'object');
+    }
+    if (value && typeof value === 'object')
+        return [value];
+    return [];
+}
+function safePositiveInt(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : 0;
+}
+function normalizeLabel(label) {
+    return label.toLowerCase().replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function parseDumpCategories(categories) {
+    const normalized = categories
+        .map((category) => ({
+        term: String(category['@_term'] ?? ''),
+        label: normalizeLabel(String(category['@_label'] ?? '')),
+    }))
+        .filter((entry) => entry.term.length > 0);
+    if (normalized.length === 0)
+        return { error: '', program: '' };
+    const errorByLabel = normalized.find((entry) => entry.label.includes('runtime error') || (entry.label.includes('error') && !entry.label.includes('program')))?.term;
+    const programByLabel = normalized.find((entry) => entry.label.includes('program'))?.term;
+    const fallbackError = normalized[0]?.term ?? '';
+    const fallbackProgram = normalized[1]?.term ?? normalized.find((entry) => entry.term !== fallbackError)?.term ?? '';
+    return {
+        error: errorByLabel ?? fallbackError,
+        program: programByLabel ?? fallbackProgram,
+    };
+}
+function extractSelfLinkHref(links) {
+    const selfLink = links.find((link) => String(link['@_rel'] ?? '') === 'self');
+    return String(selfLink?.['@_href'] ?? links[0]?.['@_href'] ?? '');
+}
+function extractDumpId(entry) {
+    const links = toRecordArray(entry.link);
+    const selfHref = extractSelfLinkHref(links);
+    const fromLink = extractIdFromPath(selfHref, ['/runtime/dump/']);
+    if (fromLink)
+        return fromLink;
+    const atomId = String(entry.id ?? '');
+    const fromAtomId = extractIdFromPath(atomId, ['/runtime/dump/', '/runtime/dumps/']);
+    if (fromAtomId)
+        return fromAtomId;
+    const serialized = JSON.stringify(entry);
+    const fallback = serialized.match(/\/runtime\/dumps?\/([^"\\\s<]+)/)?.[1] ?? '';
+    return fallback.trim();
+}
+function extractIdFromPath(rawPath, markers) {
+    const path = normalizeAdtPath(rawPath, false);
+    if (!path)
+        return '';
+    for (const marker of markers) {
+        const idx = path.indexOf(marker);
+        if (idx >= 0) {
+            const start = idx + marker.length;
+            const tail = path.slice(start);
+            const id = tail.split(/[/?#]/)[0] ?? '';
+            if (id.trim())
+                return id.trim();
+        }
+    }
+    return '';
+}
+function extractTailId(value) {
+    const normalized = normalizeAdtPath(value, false);
+    if (!normalized)
+        return value;
+    const parts = normalized.split('/').filter(Boolean);
+    return parts[parts.length - 1] ?? value;
+}
+function splitDumpSections(formattedText, chapters) {
+    if (!formattedText)
+        return {};
+    const lines = formattedText.split(/\r?\n/);
+    const sortable = chapters
+        .filter((chapter) => chapter.line > 0)
+        .sort((a, b) => {
+        if (a.line !== b.line)
+            return a.line - b.line;
+        if (a.chapterOrder !== b.chapterOrder)
+            return a.chapterOrder - b.chapterOrder;
+        return a.name.localeCompare(b.name);
+    });
+    if (sortable.length === 0)
+        return {};
+    const sections = {};
+    for (let i = 0; i < sortable.length; i++) {
+        const chapter = sortable[i];
+        const next = sortable[i + 1];
+        const startLine = Math.max(0, chapter.line - 1);
+        const endLine = next?.line ? Math.max(startLine, next.line - 1) : lines.length;
+        const rawSection = lines.slice(startLine, endLine).join('\n').trim();
+        const normalized = shouldNormalizeWrappedLines(chapter) ? joinWrappedLines(rawSection) : rawSection;
+        const sectionId = chapter.name || `section_${i + 1}`;
+        sections[sectionId] = normalized;
+    }
+    return sections;
+}
+function shouldNormalizeWrappedLines(chapter) {
+    const title = normalizeLabel(chapter.title);
+    return (title.includes('source code') ||
+        title.includes('active calls') ||
+        title.includes('call stack') ||
+        title.includes('kernel'));
+}
+function joinWrappedLines(text) {
+    if (!text.includes('\\'))
+        return text;
+    const lines = text.split('\n');
+    const result = [];
+    for (const line of lines) {
+        if (result.length > 0 && result[result.length - 1].endsWith('\\')) {
+            const prev = result[result.length - 1];
+            result[result.length - 1] = `${prev.slice(0, -1)}${line.trimStart()}`;
+            continue;
+        }
+        result.push(line);
+    }
+    return result.join('\n');
+}
+function getOptionalString(entry, keys) {
+    for (const key of keys) {
+        const value = entry[key];
+        if (value != null && String(value).trim().length > 0) {
+            return String(value);
+        }
+    }
+    return undefined;
+}
+function parseGatewayCallStack(root) {
+    const callStackNode = toRecordArray(root.callStack)[0];
+    const entries = toRecordArray(callStackNode?.entry);
+    return entries.map((entry, index) => ({
+        number: safePositiveInt(entry['@_number']) || index + 1,
+        event: String(entry['@_event'] ?? ''),
+        program: String(entry['@_program'] ?? ''),
+        name: String(entry['@_name'] ?? ''),
+        line: safePositiveInt(entry['@_line']),
+    }));
+}
+function parseGatewaySourceLines(root) {
+    const sourceCodeNode = toRecordArray(root.sourceCode)[0];
+    const lines = toRecordArray(sourceCodeNode?.line);
+    return lines.map((line, index) => ({
+        number: safePositiveInt(line['@_number']) || index + 1,
+        content: typeof line['#text'] === 'string' ? line['#text'] : String(line ?? ''),
+        isError: String(line['@_isError'] ?? '').toLowerCase() === 'true',
+    }));
+}
+function parseGatewayExceptions(root) {
+    const errorContextNode = toRecordArray(root.errorContext)[0];
+    const exceptionsNode = toRecordArray(errorContextNode?.exceptions)[0];
+    const exceptions = toRecordArray(exceptionsNode?.exception);
+    return exceptions.map((entry) => ({
+        type: String(entry['@_type'] ?? ''),
+        text: String(entry['#text'] ?? ''),
+        raiseLocation: String(entry['@_raiseLocation'] ?? ''),
+    }));
+}
+function resolveGatewayErrorDetailPath(params) {
+    const detailUrl = String(params.detailUrl ?? '').trim();
+    if (detailUrl) {
+        return normalizeAdtPath(detailUrl, true);
+    }
+    const id = String(params.id ?? '').trim();
+    if (!id) {
+        throw new Error('Gateway error detail requires either "detailUrl" or "id" with "errorType".');
+    }
+    if (id.includes('/sap/bc/adt/')) {
+        return normalizeAdtPath(id, true);
+    }
+    // Feed atom:id is emitted as "{errorType}/{transactionId}" — accept that form directly.
+    if (id.includes('/') && !params.errorType) {
+        const [derivedType, ...rest] = id.split('/');
+        const derivedId = rest.join('/');
+        if (derivedType && derivedId) {
+            return `/sap/bc/adt/gw/errorlog/${encodeURIComponent(decodeUriComponentSafe(derivedType))}/${encodeURIComponent(decodeUriComponentSafe(derivedId))}`;
+        }
+    }
+    const errorType = String(params.errorType ?? '').trim();
+    if (!errorType) {
+        throw new Error('Gateway error detail by transaction ID requires "errorType".');
+    }
+    // Feed returns display form "Frontend Error" (with space) in atom:title, but the
+    // detail URL path expects the compact identifier form "FrontendError". Strip
+    // whitespace to allow callers to pass either shape.
+    const normalizedType = errorType.replace(/\s+/g, '');
+    return `/sap/bc/adt/gw/errorlog/${encodeURIComponent(normalizedType)}/${encodeURIComponent(decodeUriComponentSafe(id))}`;
+}
+function normalizeAdtPath(rawPath, requireAdtPrefix) {
+    if (!rawPath)
+        return '';
+    const trimmed = rawPath.trim();
+    let normalized = trimmed;
+    if (/^https?:\/\//i.test(trimmed)) {
+        try {
+            const url = new URL(trimmed);
+            normalized = `${url.pathname}${url.search}`;
+        }
+        catch {
+            normalized = trimmed;
+        }
+    }
+    if (/^adt:\/\//i.test(normalized)) {
+        const marker = normalized.indexOf('/sap/bc/adt/');
+        if (marker >= 0) {
+            normalized = normalized.slice(marker);
+        }
+    }
+    if (!normalized.startsWith('/') && normalized.includes('/sap/bc/adt/')) {
+        normalized = normalized.slice(normalized.indexOf('/sap/bc/adt/'));
+    }
+    if (requireAdtPrefix && !normalized.startsWith('/sap/bc/adt/')) {
+        throw new Error(`Unsupported ADT detail URL: ${rawPath}`);
+    }
+    return normalized;
+}
+// ─── Gateway HTML helpers ──────────────────────────────────────────
+//
+// The gateway error log detail endpoint returns an HTML fragment built
+// from known section anchors. We extract tabular values with regex rather
+// than a full HTML parser to keep the dependency surface small and stay
+// resilient to whitespace/attribute variations across releases.
+function splitGatewayAtomId(atomId) {
+    const cleaned = decodeHtmlEntities(String(atomId ?? '')).trim();
+    if (!cleaned)
+        return { errorType: '', transactionId: '' };
+    const marker = '/sap/bc/adt/gw/errorlog/';
+    if (cleaned.includes(marker)) {
+        const tail = cleaned.slice(cleaned.indexOf(marker) + marker.length);
+        const [errorType, ...rest] = tail.split('/');
+        return {
+            errorType: decodeUriComponentSafe(errorType ?? ''),
+            transactionId: decodeUriComponentSafe(rest.join('/') ?? ''),
+        };
+    }
+    const slashIdx = cleaned.indexOf('/');
+    if (slashIdx >= 0) {
+        return {
+            errorType: decodeUriComponentSafe(cleaned.slice(0, slashIdx)),
+            transactionId: decodeUriComponentSafe(cleaned.slice(slashIdx + 1)),
+        };
+    }
+    return { errorType: '', transactionId: decodeUriComponentSafe(cleaned) };
+}
+function splitCamelCase(value) {
+    if (!value)
+        return '';
+    return value
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function extractEntrySummaryHtml(entry) {
+    const summary = entry.summary;
+    if (summary == null)
+        return '';
+    if (typeof summary === 'string')
+        return decodeHtmlEntities(summary);
+    const summaryNode = toRecordArray(summary)[0];
+    if (!summaryNode)
+        return '';
+    const text = summaryNode['#text'];
+    if (typeof text === 'string' && text.length > 0)
+        return decodeHtmlEntities(text);
+    return decodeHtmlEntities(String(summaryNode ?? ''));
+}
+function extractHtmlSection(html, anchorId) {
+    if (!html)
+        return '';
+    const startRe = new RegExp(`<h4[^>]*id="${escapeRegex(anchorId)}"[^>]*>`, 'i');
+    const start = html.search(startRe);
+    if (start < 0)
+        return '';
+    const rest = html.slice(start);
+    const nextH4 = rest.slice(1).search(/<h4[\s>]/i);
+    return nextH4 > 0 ? rest.slice(0, nextH4 + 1) : rest;
+}
+function extractHtmlHeaderValue(html, label) {
+    if (!html || !label)
+        return '';
+    const labelPattern = escapeRegex(label).replace(/_/g, '[_\\s]?');
+    const re = new RegExp(`<b[^>]*>\\s*(?:&nbsp;|\\s)*${labelPattern}\\s*</b>\\s*</td>\\s*<td[^>]*>([\\s\\S]*?)</td>`, 'i');
+    const match = html.match(re);
+    if (!match?.[1])
+        return '';
+    return sanitizeHtmlCellValue(match[1]);
+}
+function extractTransactionIdFromHtml(html) {
+    const raw = extractHtmlHeaderValue(html, 'Transaction ID');
+    if (!raw)
+        return '';
+    // Strip the "(Replay in GW Client)" link/suffix that SAP appends.
+    const firstToken = raw.split(/\s+/).find((part) => /^[A-Za-z0-9]{16,}$/.test(part));
+    return firstToken ?? raw;
+}
+function extractGatewayExceptionsFromHtml(contextHtml) {
+    if (!contextHtml)
+        return [];
+    const exceptionsIdx = contextHtml.search(/–\s*Exceptions\s*<\/b>/i);
+    const attributesIdx = contextHtml.search(/–\s*Attributes\s*<\/b>/i);
+    if (exceptionsIdx < 0)
+        return [];
+    const slice = contextHtml.slice(exceptionsIdx, attributesIdx > exceptionsIdx ? attributesIdx : contextHtml.length);
+    const exceptions = [];
+    const exceptionBlockRe = /<b[^>]*>[^<]*–\s*(\/?[^\s<]+)\s*<\/b>/g;
+    let match;
+    while ((match = exceptionBlockRe.exec(slice)) !== null) {
+        const name = (match[1] ?? '').trim();
+        if (!name || /^Exceptions$/i.test(name))
+            continue;
+        const afterIdx = match.index + match[0].length;
+        const block = slice.slice(afterIdx, afterIdx + 2500);
+        const text = extractHtmlHeaderValue(block, 'Text');
+        exceptions.push({ type: name, text, raiseLocation: '' });
+    }
+    return exceptions;
+}
+function extractGatewaySourceFromHtml(sourceHtml) {
+    if (!sourceHtml)
+        return { lines: [], errorLine: 0 };
+    // Line numbers and current-line markers sit in the first <td id="sourcetablecolumn">.
+    const columnMatches = Array.from(sourceHtml.matchAll(/<td[^>]*id="sourcetablecolumn"[^>]*>([\s\S]*?)<\/td>/gi));
+    const numberHtml = columnMatches[0]?.[1] ?? '';
+    const lineNumberMatches = Array.from(numberHtml.matchAll(/<span[^>]*class="linenumber[^"]*"[^>]*>([\s\S]*?)<\/span>/gi));
+    const numbers = lineNumberMatches.map((m) => {
+        const value = stripHtmlTags(m[1] ?? '').trim();
+        return /^\d+$/.test(value) ? Number(value) : null;
+    });
+    // Line source cells sit in the second <td id="sourcetablecolumn">.
+    const sourceCellHtml = columnMatches[1]?.[1] ?? '';
+    const lineDivs = Array.from(sourceCellHtml.matchAll(/<div[^>]*class="sourceline([^"]*)"[^>]*>([\s\S]*?)<\/div>/gi));
+    const lines = [];
+    let errorLine = 0;
+    let fallback = 1;
+    for (let i = 0; i < lineDivs.length; i++) {
+        const match = lineDivs[i];
+        const classes = (match[1] ?? '').trim();
+        const isError = /\bhighlight\b/i.test(classes);
+        const raw = stripHtmlTags(match[2] ?? '');
+        const content = decodeHtmlEntities(raw).replace(/\s+$/, '');
+        const assignedNumber = numbers[i];
+        const resolvedNumber = typeof assignedNumber === 'number' && assignedNumber > 0 ? assignedNumber : fallback;
+        fallback = resolvedNumber + 1;
+        lines.push({ number: resolvedNumber, content, isError });
+        if (isError && errorLine === 0)
+            errorLine = resolvedNumber;
+    }
+    return { lines, errorLine };
+}
+function extractGatewayCallStackFromHtml(stackHtml) {
+    if (!stackHtml)
+        return [];
+    const tableMatch = stackHtml.match(/<table[\s\S]*?<\/table>/i);
+    if (!tableMatch)
+        return [];
+    const tableHtml = tableMatch[0];
+    const rowMatches = Array.from(tableHtml.matchAll(/<tr[^>]*>([\s\S]*?)<\/tr>/gi));
+    const entries = [];
+    for (const row of rowMatches) {
+        const cells = Array.from(row[1].matchAll(/<td[^>]*>([\s\S]*?)<\/td>/gi)).map((m) => m[1] ?? '');
+        if (cells.length < 5)
+            continue;
+        const numberValue = Number(stripHtmlTags(cells[0]).replace(/\D+/g, '').trim());
+        if (!Number.isFinite(numberValue) || numberValue <= 0)
+            continue;
+        entries.push({
+            number: numberValue,
+            event: decodeHtmlEntities(stripHtmlTags(cells[1])).trim(),
+            program: decodeHtmlEntities(stripHtmlTags(cells[2])).trim(),
+            name: decodeHtmlEntities(stripHtmlTags(cells[3])).trim(),
+            line: safePositiveInt(stripHtmlTags(cells[4]).replace(/\D+/g, '')),
+        });
+    }
+    return entries;
+}
+function sanitizeHtmlCellValue(raw) {
+    let value = stripHtmlTags(raw);
+    value = decodeHtmlEntities(value);
+    return value.replace(/\s+/g, ' ').trim();
+}
+function stripHtmlTags(html) {
+    return String(html ?? '').replace(/<[^>]*>/g, '');
+}
+function decodeHtmlEntities(text) {
+    return String(text ?? '')
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&apos;/gi, "'")
+        .replace(/&ndash;/gi, '–')
+        .replace(/&mdash;/gi, '—')
+        .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)));
+}
+function decodeUriComponentSafe(value) {
+    if (!value?.includes('%'))
+        return value;
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 //# sourceMappingURL=diagnostics.js.map