arc-1 1.0.2 → 1.1.0

package/dist/adt/transport.js

@@ -4,7 +4,7 @@
  * Transport mutations require explicit opt-in via allowWrites + allowTransportWrites.
  * Safety checks are applied at every entry point.
  */
-import { AdtApiError } from './errors.js';
+import { AdtApiError, AdtNetworkError, AdtSafetyError } from './errors.js';
 import { checkOperation, checkTransport, OperationType } from './safety.js';
 import { decodeXmlEntities, escapeXmlAttr, findDeepNodes, parseNamedItems, parseXml } from './xml-parser.js';
 /**
@@ -30,6 +30,17 @@ export const CTS_ACCEPT_TREE = 'application/vnd.sap.adt.transportorganizertree.v
 export const CTS_CONTENT_TYPE_ORGANIZER = 'application/vnd.sap.adt.transportorganizer.v1+xml';
 /** XML namespace for CTS ADT transport manager payloads */
 export const CTS_NAMESPACE_TM = 'http://www.sap.com/cts/adt/tm';
+export const DEFAULT_RELEASE_TIMEOUT_MS = 300_000;
+const DEFAULT_RELEASE_INITIAL_DELAY_MS = 250;
+const DEFAULT_RELEASE_MAX_DELAY_MS = 2_000;
+const MODIFIABLE_RELEASE_STATUSES = new Set(['D', 'L']);
+const IN_FLIGHT_RELEASE_STATUSES = new Set(['O', 'P']);
+const TERMINAL_RELEASE_STATUSES = new Set(['R', 'N']);
+function isKnownReleaseStatus(status) {
+    return (MODIFIABLE_RELEASE_STATUSES.has(status) ||
+        IN_FLIGHT_RELEASE_STATUSES.has(status) ||
+        TERMINAL_RELEASE_STATUSES.has(status));
+}
 /** List transport requests for a user, optionally filtered by status (client-side) */
 export async function listTransports(http, safety, user, status) {
     checkTransport(safety, '', 'ListTransports', false);
@@ -274,59 +285,431 @@ export function failedReleaseReports(reports) {
     return reports.filter((r) => r.status !== '' && !r.released);
 }
 /** Release a transport request; returns the parsed release check report(s) (`[]` if none/unparseable). */
-export async function releaseTransport(http, safety, transportId) {
+export async function releaseTransport(http, safety, transportId, requestOptions) {
     checkTransport(safety, transportId, 'ReleaseTransport', true);
-    const resp = await http.post(`/sap/bc/adt/cts/transportrequests/${encodeURIComponent(transportId)}/newreleasejobs`, undefined, undefined, { Accept: CTS_CONTENT_TYPE_ORGANIZER });
+    const resp = await http.post(`/sap/bc/adt/cts/transportrequests/${encodeURIComponent(transportId)}/newreleasejobs`, undefined, undefined, { Accept: CTS_CONTENT_TYPE_ORGANIZER }, requestOptions);
     return parseReleaseReports(resp.body);
 }
+/** Collect every node with a local XML name, rather than stopping at the first matching branch. */
+function collectAllNamedNodes(value, name, output = []) {
+    if (!value || typeof value !== 'object')
+        return output;
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectAllNamedNodes(entry, name, output);
+        return output;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        if (key === name) {
+            const candidates = Array.isArray(child) ? child : [child];
+            for (const candidate of candidates) {
+                if (candidate && typeof candidate === 'object')
+                    output.push(candidate);
+            }
+        }
+        collectAllNamedNodes(child, name, output);
+    }
+    return output;
+}
 /**
- * Release a transport request recursively — tasks first, then the parent request.
+ * Flatten a transport-organizer document into request/task state rows.
  *
- * The parent request's **refreshed state** is authoritative when SAP contradicts itself: a4h 758 can
- * return HTTP 200 with `abortrelapifail` for an empty/unclassified recursive release even though the
- * parent has already reached terminal status `R`. Task releases are best-effort — the parent release
- * folds them in. A failed *task* release is therefore not fatal, and a failed parent report is
- * reconciled with one fresh request read before it is treated as blocked. `reports` remains the raw SAP
- * response; `released` lists ids confirmed either by a clean report or terminal request state.
+ * Unlike `parseTransportList`, this deliberately supports a standalone `<tm:task>` response and a
+ * task lookup whose response contains the parent request tree. That makes it safe to verify either
+ * kind of id after `newreleasejobs`.
  */
-export async function releaseTransportRecursive(http, safety, transportId) {
-    checkTransport(safety, transportId, 'ReleaseTransportRecursive', true);
-    const transport = await getTransport(http, safety, transportId);
-    const released = [];
-    if (transport) {
-        for (const task of transport.tasks) {
-            if (task.status !== 'R') {
-                checkTransport(safety, task.id, 'ReleaseTransportRecursive', true);
-                const taskReports = await releaseTransport(http, safety, task.id);
-                // Don't abort on a benign task failure; don't list a task that didn't actually release.
-                if (failedReleaseReports(taskReports).length === 0)
-                    released.push(task.id);
-            }
-        }
-        // Skip parent if already released (idempotent/retry-safe)
-        if (transport.status === 'R') {
-            return { released, reports: [] };
+export function parseTransportNodeStates(xml) {
+    const parsed = parseXml(xml);
+    const states = new Map();
+    const parentIdFrom = (value) => {
+        const raw = String(value ?? '')
+            .trim()
+            .replace(/\/+$/, '');
+        return raw.slice(raw.lastIndexOf('/') + 1);
+    };
+    const add = (node, kind, structuralParent) => {
+        const id = String(node['@_number'] ?? '').trim();
+        if (!id)
+            return;
+        const key = id.toUpperCase();
+        const status = String(node['@_status'] ?? '').toUpperCase();
+        const parentId = parentIdFrom(structuralParent ?? node['@_parent']);
+        const previous = states.get(key);
+        states.set(key, {
+            id,
+            kind,
+            ...(parentId ? { parentId } : previous?.parentId ? { parentId: previous.parentId } : {}),
+            initialStatus: status || previous?.initialStatus || '',
+            lastStatus: status || previous?.lastStatus || '',
+            confirmedReleased: TERMINAL_RELEASE_STATUSES.has(status || previous?.lastStatus || ''),
+            ...(TERMINAL_RELEASE_STATUSES.has(status || previous?.lastStatus || '')
+                ? { confirmation: 'observed_terminal' }
+                : {}),
+        });
+    };
+    for (const request of collectAllNamedNodes(parsed, 'request')) {
+        const requestId = String(request['@_number'] ?? '').trim();
+        add(request, 'request');
+        for (const task of collectAllNamedNodes(request, 'task'))
+            add(task, 'task', requestId);
+    }
+    for (const task of collectAllNamedNodes(parsed, 'task'))
+        add(task, 'task');
+    return [...states.values()];
+}
+async function readTransportNodeStates(http, safety, lookupId, requestOptions) {
+    checkTransport(safety, lookupId, 'GetTransportReleaseState', false);
+    const resp = await http.get(`/sap/bc/adt/cts/transportrequests/${encodeURIComponent(lookupId)}`, {
+        Accept: CTS_CONTENT_TYPE_ORGANIZER,
+    }, requestOptions);
+    return parseTransportNodeStates(resp.body);
+}
+const transportIdsEqual = (left, right) => (left ?? '').toUpperCase() === right.toUpperCase();
+function releaseErrorText(err) {
+    // Convergence errors bypass dispatch's minimal-error formatter. Never copy SAP
+    // response text or ADT paths into this normal tool-result evidence.
+    if (err instanceof AdtApiError)
+        return `SAP CTS request failed with HTTP ${err.statusCode}.`;
+    if (err instanceof AdtNetworkError)
+        return 'SAP CTS network request failed.';
+    const message = err instanceof Error ? err.message : String(err);
+    return message.length <= 300 ? message : `${message.slice(0, 300)}…`;
+}
+/** Fail closed when the transport allowlist cannot authorize a concurrently changing CTS subtree. */
+export function checkRecursiveTransportReleaseScope(safety) {
+    const explicitlyUnrestricted = safety.allowedTransports.length === 0 || safety.allowedTransports.some((entry) => entry.trim() === '*');
+    if (explicitlyUnrestricted)
+        return;
+    throw new AdtSafetyError('Recursive transport release is blocked by a restrictive allowedTransports policy. ' +
+        'SAP can fold a child task attached concurrently into the parent release, so exact/prefix allowlists ' +
+        'cannot authorize the complete live subtree atomically. Use an empty legacy allowlist or explicit "*" ' +
+        'only when every current and concurrently attached child of the request is authorized.');
+}
+const isTerminalReleaseReadError = (err) => err instanceof AdtApiError && [400, 401, 403, 404].includes(err.statusCode);
+function numericOption(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+async function waitForReleasePoll(milliseconds, options) {
+    if (milliseconds <= 0 || options.signal?.aborted)
+        return;
+    if (options.sleep) {
+        await options.sleep(milliseconds);
+        return;
+    }
+    await new Promise((resolve) => {
+        const timer = setTimeout(done, milliseconds);
+        const signal = options.signal;
+        signal?.addEventListener('abort', done, { once: true });
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', done);
+            resolve();
         }
+    });
+}
+function buildReleaseResult(requestedId, recursive, outcome, intended, submissions, polls, elapsedMs, lastReadError, unexpectedChildren = []) {
+    const released = (recursive
+        ? [...intended.filter((node) => node.kind === 'task'), ...intended.filter((node) => node.kind === 'request')]
+        : intended)
+        .filter((node) => node.confirmedReleased)
+        .map((node) => node.id);
+    const reports = submissions.find((submission) => transportIdsEqual(submission.id, requestedId))?.reports ?? [];
+    const reportConflicts = submissions
+        .filter((submission) => failedReleaseReports(submission.reports).length > 0 &&
+        intended.some((node) => transportIdsEqual(node.id, submission.id) && node.confirmedReleased))
+        .map((submission) => submission.id);
+    return {
+        requestedId,
+        recursive,
+        outcome,
+        verified: outcome === 'released',
+        released,
+        intended: intended.map((node) => ({ ...node })),
+        submissions: submissions.map((submission) => ({ ...submission, reports: [...submission.reports] })),
+        reports,
+        polls,
+        elapsedMs,
+        ...(lastReadError ? { lastReadError } : {}),
+        ...(reportConflicts.length > 0 ? { reportConflicts } : {}),
+        ...(unexpectedChildren.length > 0 ? { unexpectedChildren: [...unexpectedChildren] } : {}),
+    };
+}
+async function prepareTransportRelease(http, safety, transportId, recursive, operation, requestOptions, stoppedBeforeSubmission) {
+    const terminal = (intended, detail, outcome = 'unknown') => ({ intended, terminal: { outcome, detail } });
+    let discovered;
+    try {
+        discovered = await readTransportNodeStates(http, safety, transportId, requestOptions);
+    }
+    catch (err) {
+        return terminal([], releaseErrorText(err));
+    }
+    const requested = discovered.find((node) => transportIdsEqual(node.id, transportId));
+    if (!requested) {
+        return terminal([], `Transport '${transportId}' was not present in the CTS state response.`);
+    }
+    if (recursive && requested.kind !== 'request') {
+        return terminal([requested], `Recursive release requires a parent request, but '${transportId}' is a task.`);
     }
-    const reports = await releaseTransport(http, safety, transportId);
-    if (failedReleaseReports(reports).length === 0) {
-        released.push(transportId);
+    const intended = [
+        requested,
+        ...(recursive
+            ? discovered.filter((node) => node.kind === 'task' && transportIdsEqual(node.parentId, transportId))
+            : []),
+    ].map((node) => ({ ...node }));
+    for (const node of intended)
+        checkTransport(safety, node.id, operation, true);
+    const unknown = intended.filter((node) => !isKnownReleaseStatus(node.lastStatus));
+    if (unknown.length > 0) {
+        const detail = `CTS returned an unknown initial status for: ${unknown
+            .map((node) => `${node.id}=${node.lastStatus || '(missing)'}`)
+            .join(', ')}.`;
+        return terminal(intended, detail);
     }
-    else {
-        // SAP can report abortrelapifail after it has already committed the recursive parent release.
-        // Reconcile that contradictory HTTP-200 body against the actual request state. If the read fails
-        // or the request is still modifiable, preserve the failed report as the authoritative outcome.
+    if (intended.every((node) => node.confirmedReleased))
+        return terminal(intended, undefined, 'released');
+    const stopped = stoppedBeforeSubmission();
+    if (!stopped)
+        return { intended };
+    const detail = stopped === 'aborted'
+        ? 'Transport release verification was aborted before submission.'
+        : 'Transport release deadline expired before submission.';
+    return terminal(intended, detail);
+}
+async function releaseTransportWithConvergence(http, safety, transportId, recursive, options) {
+    const operation = recursive ? 'ReleaseTransportRecursive' : 'ReleaseTransport';
+    checkTransport(safety, transportId, operation, true);
+    if (recursive)
+        checkRecursiveTransportReleaseScope(safety);
+    const now = options.now ?? Date.now;
+    const startedAt = now();
+    const relativeDeadline = startedAt + numericOption(options.timeoutMs, DEFAULT_RELEASE_TIMEOUT_MS);
+    const suppliedDeadline = typeof options.deadline === 'number' && Number.isFinite(options.deadline)
+        ? options.deadline
+        : Number.POSITIVE_INFINITY;
+    const deadline = Math.min(relativeDeadline, suppliedDeadline);
+    const elapsed = () => Math.max(0, now() - startedAt);
+    const requestOptions = { deadline, signal: options.signal };
+    const initialResult = (outcome, intended = [], detail) => buildReleaseResult(transportId, recursive, outcome, intended, [], 0, elapsed(), detail);
+    const preparation = await prepareTransportRelease(http, safety, transportId, recursive, operation, requestOptions, () => (options.signal?.aborted ? 'aborted' : now() >= deadline ? 'deadline' : undefined));
+    const { intended } = preparation;
+    if (preparation.terminal) {
+        return initialResult(preparation.terminal.outcome, intended, preparation.terminal.detail);
+    }
+    const submissions = [];
+    const requestedState = intended[0];
+    const taskSubmissionOrder = recursive ? intended.filter((node) => node.kind === 'task') : [];
+    const frozenTaskKeys = new Set(taskSubmissionOrder.map((node) => node.id.toUpperCase()));
+    let polls = 0;
+    let lastReadError;
+    let missingIds = [];
+    let unexpectedChildren = [];
+    const maxDelayMs = numericOption(options.maxDelayMs, DEFAULT_RELEASE_MAX_DELAY_MS);
+    let delayMs = Math.min(numericOption(options.initialDelayMs, DEFAULT_RELEASE_INITIAL_DELAY_MS), maxDelayMs);
+    const lookupId = recursive ? requestedState.id : transportId;
+    const allReleased = () => intended.every((node) => node.confirmedReleased);
+    const hasInFlightNode = () => intended.some((node) => IN_FLIGHT_RELEASE_STATUSES.has(node.lastStatus) && !node.confirmedReleased);
+    const submissionFailed = () => submissions.some((submission) => submission.error !== undefined);
+    const finalOutcomeIsDecided = () => !hasInFlightNode() &&
+        submissions.some((submission) => submission.error !== undefined ||
+            (transportIdsEqual(submission.id, requestedState.id) && failedReleaseReports(submission.reports).length > 0));
+    const submissionWasAccepted = (id) => {
+        const submission = submissions.find((entry) => transportIdsEqual(entry.id, id));
+        return (submission !== undefined &&
+            submission.error === undefined &&
+            submission.reports.length > 0 &&
+            failedReleaseReports(submission.reports).length === 0);
+    };
+    const result = (outcome, detail) => buildReleaseResult(transportId, recursive, outcome, intended, submissions, polls, elapsed(), detail, unexpectedChildren);
+    const submissionFailureDetail = () => {
+        const failed = submissions.filter((submission) => submission.error);
+        return failed.length === 0
+            ? undefined
+            : `Release submission returned an error for ${failed
+                .map((submission) => `${submission.id}: ${submission.error}`)
+                .join('; ')}. The submission outcome is uncertain; use the returned CTS state before retrying.`;
+    };
+    const finishWithoutTerminalRelease = () => {
+        const unknownStatuses = intended.filter((node) => !isKnownReleaseStatus(node.lastStatus));
+        const submissionFailure = submissionFailureDetail();
+        const stateDetail = lastReadError ??
+            (missingIds.length > 0
+                ? `CTS state omitted intended id(s): ${missingIds.join(', ')}.`
+                : unknownStatuses.length > 0
+                    ? `CTS returned unknown status(es): ${unknownStatuses
+                        .map((node) => `${node.id}=${node.lastStatus || '(missing)'}`)
+                        .join(', ')}.`
+                    : undefined);
+        const detail = [submissionFailure, stateDetail].filter(Boolean).join(' ') || undefined;
+        const unknown = detail || unexpectedChildren.length > 0;
+        const blocked = submissions.some((submission) => failedReleaseReports(submission.reports).length > 0);
+        return result(unknown ? 'unknown' : blocked ? 'blocked' : 'timeout', detail);
+    };
+    const submit = async (node) => {
+        try {
+            const reports = await releaseTransport(http, safety, node.id, requestOptions);
+            submissions.push({ id: node.id, reports });
+        }
+        catch (err) {
+            submissions.push({ id: node.id, reports: [], error: releaseErrorText(err) });
+        }
+    };
+    const refresh = async () => {
         try {
-            const refreshed = await getTransport(http, safety, transportId);
-            if (refreshed?.status === 'R')
-                released.push(transportId);
+            const latest = await readTransportNodeStates(http, safety, lookupId, requestOptions);
+            polls += 1;
+            lastReadError = undefined;
+            const latestById = new Map(latest.map((node) => [node.id.toUpperCase(), node]));
+            unexpectedChildren = recursive
+                ? latest
+                    .filter((node) => node.kind === 'task' &&
+                    transportIdsEqual(node.parentId, requestedState.id) &&
+                    !frozenTaskKeys.has(node.id.toUpperCase()))
+                    .map((node) => node.id)
+                    .sort()
+                : [];
+            missingIds = [];
+            const observedParent = latestById.get(requestedState.id.toUpperCase());
+            const parentIsTerminal = recursive && observedParent !== undefined && TERMINAL_RELEASE_STATUSES.has(observedParent.lastStatus);
+            for (const node of intended) {
+                const observed = latestById.get(node.id.toUpperCase());
+                if (observed) {
+                    node.lastStatus = observed.lastStatus;
+                    node.confirmedReleased = TERMINAL_RELEASE_STATUSES.has(node.lastStatus);
+                    node.confirmation = node.confirmedReleased ? 'observed_terminal' : undefined;
+                    continue;
+                }
+                const alreadyConfirmed = node.confirmedReleased;
+                const existingConfirmation = node.confirmation;
+                const disappearedReleasedTask = node.kind === 'task' && (parentIsTerminal || alreadyConfirmed || submissionWasAccepted(node.id));
+                if (disappearedReleasedTask) {
+                    node.confirmedReleased = true;
+                    node.confirmation = parentIsTerminal
+                        ? 'parent_terminal'
+                        : alreadyConfirmed
+                            ? existingConfirmation
+                            : 'accepted_submission_absence';
+                }
+                else {
+                    node.lastStatus = '';
+                    node.confirmedReleased = false;
+                    node.confirmation = undefined;
+                    missingIds.push(node.id);
+                }
+            }
+        }
+        catch (err) {
+            polls += 1;
+            if (err instanceof AdtApiError &&
+                err.statusCode === 404 &&
+                requestedState.kind === 'task' &&
+                submissionWasAccepted(requestedState.id)) {
+                requestedState.confirmedReleased = true;
+                requestedState.confirmation = 'accepted_submission_absence';
+                lastReadError = undefined;
+                missingIds = [];
+                return result('released');
+            }
+            lastReadError = releaseErrorText(err);
+            if (isTerminalReleaseReadError(err)) {
+                return result('unknown', [submissionFailureDetail(), lastReadError].filter(Boolean).join(' '));
+            }
+            return undefined;
         }
-        catch {
-            // The caller will surface the original release report, which is more actionable than a
-            // best-effort reconciliation-read failure.
+        if (unexpectedChildren.length > 0) {
+            const parentWasSubmitted = submissions.some((submission) => transportIdsEqual(submission.id, requestedState.id));
+            const detail = parentWasSubmitted
+                ? `CTS added non-frozen child task(s) during recursive release: ${unexpectedChildren.join(', ')}. ` +
+                    'Exact-set terminal verification was refused.'
+                : `CTS added non-frozen child task(s) before parent release: ${unexpectedChildren.join(', ')}. ` +
+                    'The parent release was not submitted.';
+            return result('unknown', detail);
         }
+        return allReleased() ? result('released') : undefined;
+    };
+    const stopped = () => {
+        if (options.signal?.aborted) {
+            const detail = [submissionFailureDetail(), 'Transport release verification was aborted.']
+                .filter(Boolean)
+                .join(' ');
+            return result('unknown', detail);
+        }
+        return now() >= deadline ? finishWithoutTerminalRelease() : undefined;
+    };
+    const pollUntil = async (ready, immediate) => {
+        while (true) {
+            if (!immediate) {
+                const beforeSleep = stopped();
+                if (beforeSleep)
+                    return beforeSleep;
+                await waitForReleasePoll(Math.min(delayMs, Math.max(0, deadline - now())), options);
+                delayMs = Math.min(maxDelayMs, Math.max(delayMs === 0 ? 1 : delayMs, delayMs * 2));
+                const afterSleep = stopped();
+                if (afterSleep)
+                    return afterSleep;
+            }
+            immediate = false;
+            const terminal = await refresh();
+            if (terminal)
+                return terminal;
+            // A transient read leaves lastReadError set. Never authorize a phase transition from stale state.
+            if (lastReadError === undefined && ready())
+                return stopped();
+        }
+    };
+    // Phase 1: poll O, then submit each frozen D task at most once.
+    if (recursive) {
+        if (hasInFlightNode()) {
+            const terminal = await pollUntil(() => !hasInFlightNode(), true);
+            if (terminal)
+                return terminal;
+        }
+        for (const node of taskSubmissionOrder) {
+            if (node.confirmedReleased)
+                continue;
+            if (!MODIFIABLE_RELEASE_STATUSES.has(node.lastStatus))
+                break;
+            await submit(node);
+            if (submissionFailed())
+                break;
+        }
+        // Phase 2: only a coherent fresh tree snapshot may authorize the parent POST.
+        const preParent = await pollUntil(() => submissionFailed() ||
+            (missingIds.length === 0 &&
+                (MODIFIABLE_RELEASE_STATUSES.has(requestedState.lastStatus) || requestedState.confirmedReleased) &&
+                taskSubmissionOrder.every((node) => MODIFIABLE_RELEASE_STATUSES.has(node.lastStatus) || node.confirmedReleased)), true);
+        if (preParent)
+            return preParent;
+        if (!submissionFailed() && MODIFIABLE_RELEASE_STATUSES.has(requestedState.lastStatus)) {
+            await submit(requestedState);
+            const terminal = await pollUntil(finalOutcomeIsDecided, true);
+            return terminal ?? finishWithoutTerminalRelease();
+        }
+        const terminal = await pollUntil(finalOutcomeIsDecided, false);
+        return terminal ?? finishWithoutTerminalRelease();
+    }
+    if (IN_FLIGHT_RELEASE_STATUSES.has(requestedState.lastStatus)) {
+        const terminal = await pollUntil(() => MODIFIABLE_RELEASE_STATUSES.has(requestedState.lastStatus), true);
+        if (terminal)
+            return terminal;
     }
-    return { released, reports };
+    if (MODIFIABLE_RELEASE_STATUSES.has(requestedState.lastStatus))
+        await submit(requestedState);
+    const terminal = await pollUntil(finalOutcomeIsDecided, true);
+    return terminal ?? finishWithoutTerminalRelease();
+}
+/** Release one request/task and return after terminal CTS state or accepted released-task disappearance. */
+export async function releaseTransportAndWait(http, safety, transportId, options = {}) {
+    return releaseTransportWithConvergence(http, safety, transportId, false, options);
+}
+/**
+ * Release a parent request recursively — tasks first, then the parent — and wait until the frozen
+ * parent/task set has terminal CTS evidence. Raw failed reports are preserved but final CTS state is authoritative.
+ * SAP has no atomic compare-tree-and-release operation: exact/prefix transport allowlists are therefore
+ * refused, and any non-frozen child observed by the mandatory pre-parent snapshot or readback makes the
+ * result unverified. The fresh snapshot narrows, but cannot eliminate, the backend's GET-to-POST race.
+ */
+export async function releaseTransportRecursive(http, safety, transportId, options = {}) {
+    return releaseTransportWithConvergence(http, safety, transportId, true, options);
 }
 /**
  * Remove a single object from a transport task.
@@ -696,6 +1079,24 @@ function parseTransportList(xml) {
                 objects,
             };
         });
+        // Request-level <tm:abap_object> children, read STRUCTURALLY.
+        //
+        // findDeepNodes must not be used here: it only stops early when the key is a DIRECT
+        // property, and on the common shape (objects only under tasks) it recurses into <tm:task>
+        // and returns the first task's objects — which would duplicate them onto the request and
+        // stamp them with the request id instead of their task's.
+        const directObjects = req.abap_object;
+        const requestObjects = (Array.isArray(directObjects) ? directObjects : directObjects ? [directObjects] : [])
+            .filter((o) => !!o && typeof o === 'object')
+            .map((o) => ({
+            pgmid: String(o['@_pgmid'] ?? ''),
+            type: String(o['@_type'] ?? ''),
+            name: String(o['@_name'] ?? ''),
+            wbtype: String(o['@_wbtype'] ?? ''),
+            description: String(o['@_obj_desc'] ?? o['@_obj_info'] ?? ''),
+            locked: String(o['@_lock_status'] ?? '') === 'X',
+            position: String(o['@_position'] ?? '000000'),
+        }));
         return {
             id: String(req['@_number'] ?? ''),
             description: String(req['@_desc'] ?? ''),
@@ -705,6 +1106,7 @@ function parseTransportList(xml) {
             target: String(req['@_target'] ?? ''),
             targetDesc: String(req['@_target_desc'] ?? ''),
             tasks,
+            ...(requestObjects.length ? { requestObjects } : {}),
         };
     });
 }