@mcp-abap-adt/adt-clients 34.2.0 → 35.0.0

package/README.md

@@ -834,20 +834,28 @@ Some ADT endpoints return `406` when the `Accept` header does not match the
 system's supported media types. The client retries once with a type the `406`
 names, and remembers it for that endpoint.
 
-**It is on unless you turn it off** — per client, or for the process:
+**It is off unless you turn it on** (since 35.0.0) — per client, or for the
+process. Without a switch a `406` or `415` is the call's answer and nothing is
+sent again:
 
 ```typescript
 import { AdtClient } from '@mcp-abap-adt/adt-clients';
 
 const client = new AdtClient(connection, console, {
-  enableAcceptCorrection: false,
+  enableAcceptCorrection: true,
 });
 ```
 
 ```bash
-ADT_ACCEPT_CORRECTION=false npm test
+ADT_ACCEPT_CORRECTION=true npm test
 ```
 
+The variable turns it on only when it is exactly `true`. To correct requests
+yourself instead, read a `406` with `extractSupportedAccept(error)` and keep
+the result in the connection's cache with `rememberAccept(connection, request,
+accept)`; `cachedAccept(connection, request)` reads it back, whatever the
+switch says. See [batch](docs/usage/BATCH.md).
+
 **The state is the connection's** since 23.0.0: the remembered types and the
 switch live on the connection object. They used to be module globals, so a
 header learned on one system was sent to every other, and one client's switch
@@ -1021,6 +1029,7 @@ See [Architecture Documentation](docs/architecture/ARCHITECTURE.md#type-system-a
 One document per breaking release, each written for a consumer on the contract
 before it:
 
+- **[34.x → 35.0.0](docs/usage/MIGRATION-35.md)** — accept negotiation is off by default: a `406`/`415` is the call's answer unless you switch it on.
 - **[33.x → 34.0.0](docs/usage/MIGRATION-34.md)** — a batch corrects and resends nothing: a part's `406`/`415` is that call's answer.
 - **[32.x → 33.0.0](docs/usage/MIGRATION-33.md)** — a credential the provider refused before SAP was asked rejects with the connection's refusal as it came; a `401` SAP refused it with comes back carrying that response.
 - **[31.x → 32.0.0](docs/usage/MIGRATION-32.md)** — interfaces-adt 18, three enhancement subtypes, subtype-specific create fields, two new result slots for enhancement hosts, and `metadataUpdated` for enhancement document writes.

package/dist/batch/AdtBatchConnection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAS9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAWH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAiG3C"}
+{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAU9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAWH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAmH3C"}

package/dist/batch/AdtBatchConnection.js

@@ -4,6 +4,7 @@ exports.AdtBatchConnection = void 0;
 const objects_1 = require("../endpoints/objects");
 const acceptNegotiation_1 = require("../utils/acceptNegotiation");
 const adtResponse_1 = require("../utils/adtResponse");
+const requestTrace_1 = require("../utils/requestTrace");
 const wire_1 = require("./wire");
 /** Records member requests; execute also drains requests queued during settlement. */
 class AdtBatchConnection {
@@ -149,6 +150,25 @@ class AdtBatchConnection {
             const unsentError = (0, adtResponse_1.isUnansweredCredentialRefusal)(error)
                 ? error
                 : new Error('ADT batch request not sent because an earlier batch envelope failed', { cause: error });
+            // The envelope failed as a whole: every part it carried rejects with
+            // this one object. The request that failed is the envelope's own POST,
+            // not any part — and no part's trace may write its own over it.
+            // Marked first: the mark cannot fail. The request is written only where
+            // the failure takes it — a frozen one does not, and the parts settle
+            // with it as it came either way.
+            if (active.length && !(0, adtResponse_1.isUnansweredCredentialRefusal)(error)) {
+                (0, requestTrace_1.markEnvelopeFailure)(error);
+                if (error !== null && typeof error === 'object')
+                    Reflect.defineProperty(error, 'request', {
+                        value: { method: 'POST', url: objects_1.BATCH[this.options.endpoint] },
+                        writable: true,
+                        enumerable: true,
+                        configurable: true,
+                    });
+            }
+            // The "not sent" failure is one object shared by every unsent part, too.
+            if (unsentError !== error)
+                (0, requestTrace_1.markEnvelopeFailure)(unsentError);
             this.settlementFailure = { error: unsentError };
             for (const part of active)
                 part.reject(error);

package/dist/index.d.ts

@@ -26,5 +26,5 @@ export * from './index.executors';
 export * from './index.readings';
 export * from './index.runtime';
 export * from './index.ws';
-export { exemptFromAcceptNegotiation, getBaseRequest, } from './utils/acceptNegotiation';
+export { cachedAccept, exemptFromAcceptNegotiation, extractSupportedAccept, getBaseRequest, rememberAccept, } from './utils/acceptNegotiation';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,2BAA2B,EAC3B,cAAc,GACf,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,YAAY,EACZ,2BAA2B,EAC3B,sBAAsB,EACtB,cAAc,EACd,cAAc,GACf,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -34,7 +34,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBaseRequest = exports.exemptFromAcceptNegotiation = exports.CT_INCLUDE = exports.AdtInclude = exports.AdtBatchConnection = void 0;
+exports.rememberAccept = exports.getBaseRequest = exports.extractSupportedAccept = exports.exemptFromAcceptNegotiation = exports.cachedAccept = exports.CT_INCLUDE = exports.AdtInclude = exports.AdtBatchConnection = void 0;
 var batch_1 = require("./batch");
 Object.defineProperty(exports, "AdtBatchConnection", { enumerable: true, get: function () { return batch_1.AdtBatchConnection; } });
 var include_1 = require("./core/include");
@@ -47,5 +47,8 @@ __exportStar(require("./index.readings"), exports);
 __exportStar(require("./index.runtime"), exports);
 __exportStar(require("./index.ws"), exports);
 var acceptNegotiation_1 = require("./utils/acceptNegotiation");
+Object.defineProperty(exports, "cachedAccept", { enumerable: true, get: function () { return acceptNegotiation_1.cachedAccept; } });
 Object.defineProperty(exports, "exemptFromAcceptNegotiation", { enumerable: true, get: function () { return acceptNegotiation_1.exemptFromAcceptNegotiation; } });
+Object.defineProperty(exports, "extractSupportedAccept", { enumerable: true, get: function () { return acceptNegotiation_1.extractSupportedAccept; } });
 Object.defineProperty(exports, "getBaseRequest", { enumerable: true, get: function () { return acceptNegotiation_1.getBaseRequest; } });
+Object.defineProperty(exports, "rememberAccept", { enumerable: true, get: function () { return acceptNegotiation_1.rememberAccept; } });

package/dist/utils/acceptNegotiation.d.ts

@@ -17,10 +17,28 @@ export interface IAcceptNegotiationOptions {
 export declare function clearAcceptCache(connection: IAbapConnection): void;
 /** Switch correction on or off for this connection alone. */
 export declare function setAcceptCorrectionEnabled(connection: IAbapConnection, enabled?: boolean): void;
-/** This connection's switch, or the `ADT_ACCEPT_CORRECTION` default. */
+/**
+ * This connection's switch, else the `ADT_ACCEPT_CORRECTION` default. Off
+ * unless explicitly on: the environment variable turns it on only when it is
+ * exactly `true`; unset, or any other value, leaves it off.
+ */
 export declare function getAcceptCorrectionEnabled(connection: IAbapConnection): boolean;
 export declare function extractSupportedAccept(error: unknown): string[];
 export declare function extractSupportedContentType(error: unknown): string[];
+/**
+ * The Accept stored for `request`'s method and URL on this connection: what a
+ * `406` taught negotiation or `rememberAccept` stored, or `undefined` when
+ * there is none. A plain read of the per-connection cache, whatever the
+ * correction switch says, so a consumer that corrects requests itself can read
+ * it while negotiation is off.
+ */
+export declare function cachedAccept(connection: IAbapConnection, request: IAbapRequestOptions): string | undefined;
+/**
+ * Store a corrected Accept for `request`'s method and URL on this connection,
+ * as the negotiation's own `406` branch does: a later request through the
+ * connection's negotiation sends it. A plain write of the per-connection cache.
+ */
+export declare function rememberAccept(connection: IAbapConnection, request: IAbapRequestOptions, accept: string): void;
 /**
  * The connection's request as it was before an `AdtClient` with correction on
  * wrapped it: accept negotiation corrects and resends nothing. The

package/dist/utils/acceptNegotiation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acceptNegotiation.d.ts","sourceRoot":"","sources":["../../src/utils/acceptNegotiation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAkD9D;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAM7E;AAaD,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAIlE;AAED,6DAA6D;AAC7D,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI,CAEN;AAED,wEAAwE;AACxE,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAIT;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoC/D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAsCpE;AAMD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,GAC1B,eAAe,CAAC,gBAAgB,CAAC,CAInC;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,GACf,IAAI,CAkBN;AAED,wBAAsB,mCAAmC,CACvD,CAAC,GAAG,OAAO,EACX,CAAC,GAAG,OAAO,EAEX,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAkFjC"}
+{"version":3,"file":"acceptNegotiation.d.ts","sourceRoot":"","sources":["../../src/utils/acceptNegotiation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAkD9D;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAM7E;AAaD,MAAM,WAAW,yBAAyB;IACxC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,2CAA2C;AAC3C,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAIlE;AAED,6DAA6D;AAC7D,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,EAC3B,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI,CAEN;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,eAAe,GAC1B,OAAO,CAIT;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoC/D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAsCpE;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,GAC3B,MAAM,GAAG,SAAS,CAEpB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,CAEN;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,eAAe,GAC1B,eAAe,CAAC,gBAAgB,CAAC,CAInC;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,GACf,IAAI,CAkBN;AAED,wBAAsB,mCAAmC,CACvD,CAAC,GAAG,OAAO,EACX,CAAC,GAAG,OAAO,EAEX,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,yBAAyB,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAkFjC"}

package/dist/utils/acceptNegotiation.js

@@ -6,6 +6,8 @@ exports.setAcceptCorrectionEnabled = setAcceptCorrectionEnabled;
 exports.getAcceptCorrectionEnabled = getAcceptCorrectionEnabled;
 exports.extractSupportedAccept = extractSupportedAccept;
 exports.extractSupportedContentType = extractSupportedContentType;
+exports.cachedAccept = cachedAccept;
+exports.rememberAccept = rememberAccept;
 exports.getBaseRequest = getBaseRequest;
 exports.wrapConnectionAcceptNegotiation = wrapConnectionAcceptNegotiation;
 exports.makeAdtRequestWithAcceptNegotiation = makeAdtRequestWithAcceptNegotiation;
@@ -59,12 +61,16 @@ function clearAcceptCache(connection) {
 function setAcceptCorrectionEnabled(connection, enabled) {
     stateOf(connection).enabled = enabled;
 }
-/** This connection's switch, or the `ADT_ACCEPT_CORRECTION` default. */
+/**
+ * This connection's switch, else the `ADT_ACCEPT_CORRECTION` default. Off
+ * unless explicitly on: the environment variable turns it on only when it is
+ * exactly `true`; unset, or any other value, leaves it off.
+ */
 function getAcceptCorrectionEnabled(connection) {
     const enabled = stateOf(connection).enabled;
     if (enabled !== undefined)
         return enabled;
-    return process.env.ADT_ACCEPT_CORRECTION !== 'false';
+    return process.env.ADT_ACCEPT_CORRECTION === 'true';
 }
 function extractSupportedAccept(error) {
     const types = new Set();
@@ -134,6 +140,24 @@ function extractSupportedContentType(error) {
 function buildCacheKey(request) {
     return `${request.method.toUpperCase()} ${request.url}`;
 }
+/**
+ * The Accept stored for `request`'s method and URL on this connection: what a
+ * `406` taught negotiation or `rememberAccept` stored, or `undefined` when
+ * there is none. A plain read of the per-connection cache, whatever the
+ * correction switch says, so a consumer that corrects requests itself can read
+ * it while negotiation is off.
+ */
+function cachedAccept(connection, request) {
+    return stateOf(connection).accept.get(buildCacheKey(request));
+}
+/**
+ * Store a corrected Accept for `request`'s method and URL on this connection,
+ * as the negotiation's own `406` branch does: a later request through the
+ * connection's negotiation sends it. A plain write of the per-connection cache.
+ */
+function rememberAccept(connection, request, accept) {
+    stateOf(connection).accept.set(buildCacheKey(request), accept);
+}
 /**
  * The connection's request as it was before an `AdtClient` with correction on
  * wrapped it: accept negotiation corrects and resends nothing. The

package/dist/utils/requestTrace.d.ts

@@ -44,6 +44,12 @@ export interface IAdtRequestTrace {
  * the field only when it means something.
  */
 export declare function requestOf(answer?: IAdtWireResponse): IAdtRequestTrace | undefined;
+/**
+ * Mark `error` as a batch envelope's failure, so the trace leaves it as it
+ * came. Module-internal (not in the package's index): the batch connection is
+ * its one caller.
+ */
+export declare function markEnvelopeFailure(error: unknown): void;
 /**
  * Put the request back on the answer.
  *

package/dist/utils/requestTrace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestTrace.d.ts","sourceRoot":"","sources":["../../src/utils/requestTrace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAGjD,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,CAAC,EAAE,gBAAgB,GACxB,gBAAgB,GAAG,SAAS,CAI9B;AAKD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,eAAe,CAmD7E"}
+{"version":3,"file":"requestTrace.d.ts","sourceRoot":"","sources":["../../src/utils/requestTrace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,eAAe,EAEf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAGjD,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACvB,MAAM,CAAC,EAAE,gBAAgB,GACxB,gBAAgB,GAAG,SAAS,CAI9B;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAExD;AAWD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,eAAe,GAAG,eAAe,CAsD7E"}

package/dist/utils/requestTrace.js

@@ -32,6 +32,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestOf = requestOf;
+exports.markEnvelopeFailure = markEnvelopeFailure;
 exports.withRequestTrace = withRequestTrace;
 const adtResponse_1 = require("./adtResponse");
 /**
@@ -48,6 +49,31 @@ function requestOf(answer) {
         return undefined;
     return { method: carried.method, url: carried.url };
 }
+/**
+ * The mark of a batch envelope's failure: one object, rejected to every part
+ * the envelope carried. Each part's request passes through the trace, and a
+ * part writing its own request onto that shared object would name itself on
+ * every other part's failure — the last part's winning, a request never sent
+ * on its own. The object carries the envelope's own request instead, set by
+ * the batch connection that sent it.
+ *
+ * Kept in a `WeakSet` rather than under a symbol on the error: a transport may
+ * reject with a frozen error, which takes no property, and the mark must hold
+ * on it all the same — the parts settle with that failure as it came.
+ */
+const envelopeFailures = new WeakSet();
+/**
+ * Mark `error` as a batch envelope's failure, so the trace leaves it as it
+ * came. Module-internal (not in the package's index): the batch connection is
+ * its one caller.
+ */
+function markEnvelopeFailure(error) {
+    if (error !== null && typeof error === 'object')
+        envelopeFailures.add(error);
+}
+function isEnvelopeFailure(error) {
+    return (error !== null && typeof error === 'object' && envelopeFailures.has(error));
+}
 /** Connections already carrying the trace. */
 const traced = new WeakSet();
 /**
@@ -101,8 +127,10 @@ function withRequestTrace(connection) {
             //
             // A credential refusal SAP was never asked about is not annotated: it is
             // the connection's own object, rethrown to the caller as it came, and
-            // this wrapper does not write onto it.
-            if ((0, adtResponse_1.isUnansweredCredentialRefusal)(error))
+            // this wrapper does not write onto it. Nor is a batch envelope's
+            // failure: every part of the envelope rejects with that one object, and
+            // it already names the request that failed — the envelope's own.
+            if ((0, adtResponse_1.isUnansweredCredentialRefusal)(error) || isEnvelopeFailure(error))
                 throw error;
             error.request = asked;
             throw error;

package/docs/usage/BATCH.md

@@ -73,7 +73,8 @@ Use the real handles and inspect activation messages, including `type="E"`.
 The transport provides no transaction or rollback; callers own recovery and
 cleanup after partial failures.
 
-Accept negotiation never corrects or resends an envelope or its parts. A batch
+Accept negotiation never corrects or resends an envelope or its parts. (Since
+35.0.0 it corrects nothing anywhere unless switched on.) A batch
 connection is exempt from it: an `AdtClient` built over one does not wrap it,
 whatever `enableAcceptCorrection` it is given, and a member that negotiates by
 itself sends through it once. On a connection an `AdtClient` wrapped with
@@ -86,7 +87,27 @@ and is negotiated like any other; mark it with `exemptFromAcceptNegotiation(wrap
 (exported by the package) and it is exempt too. When the batch connection wraps
 a forwarder of yours over a connection an `AdtClient` wrapped, forward through
 `getBaseRequest(thatConnection)` (exported): the envelope then bypasses that
-connection's accept negotiation and is sent once. A batch is yours, and so is
+connection's accept negotiation and is sent once. To correct a part that SAP
+answered with `406` yourself, read the acceptable formats from that answer with
+`extractSupportedAccept(error)` (exported): it takes the error the `406` came
+as — any value; one without a response yields an empty list — and returns the
+supported media types as a `string[]`. It reads them from the response headers
+`accept`, `x-sap-adt-supported-accept`, `x-sap-adt-accept`, `supported-accept`
+and `accept-supported` (comma-separated), and from every `type/subtype`
+(with an optional `;parameter`) found in the response body, without
+duplicates. It is the reading accept negotiation applies to a `406` itself.
+
+The corrected Accept is remembered where negotiation remembers its own: the
+connection's accept cache, keyed by method and URL. `cachedAccept(connection,
+request)` (exported) returns the Accept stored for that request's method and
+URL on that connection — what a `406` taught negotiation or `rememberAccept`
+stored — or `undefined` when there is none. It is a plain read of the cache and
+ignores the correction switch, so a consumer that corrects requests itself can
+use it while negotiation is off. `rememberAccept(connection, request, accept)` (exported) stores
+`accept` for the request's method and URL on the connection and returns nothing;
+a later request through an `AdtClient` with correction on over the same
+connection sends it (with correction off, only the consumer's own code reads it). Both read and write that cache only, so a correction
+learned on either path serves both. A batch is yours, and so is
 what SAP answered to each of its parts. The envelope request itself still goes
 through the connection's own handling — credential renewal, CSRF recovery and
 session — as every request does: that is about the connection to the endpoint,
@@ -118,9 +139,14 @@ Recorded request promises receive inner responses, in order: 2xx resolves; other
 statuses reject with an Error carrying `response: { status, statusText, headers,
 data }`, matching direct HTTP failure handling. Members keep their usual
 `IAdtResponse` and strategy behavior. Envelope/parse failures stop execution immediately and reject `execute()` and
-parts in the failed envelope. Unsent runs and queued follow-ups reject with a
+parts in the failed envelope. Every part of that envelope rejects with the same
+object and message, and its `request` is the envelope's own
+(`{ method: 'POST', url: '/sap/bc/adt/communication/batch' }`, or the debugger's
+batch URL), not any part's; a failure that takes no property, a frozen one,
+reaches every part as it came, without it. Unsent runs and queued follow-ups reject with a
 library error saying the request was not sent because an earlier envelope failed;
-that error carries the cause, without a SAP response. Missing parts reject with a part-count error. A count
+that error carries the cause, without a SAP response and without a `request` of
+its own. Missing parts reject with a part-count error. A count
 mismatch also rejects `execute()`. Attach rejection handlers before execution when
 using raw connection promises. Each execute sends follow-up envelopes for requests recorded during settlement
 by member continuations; accept negotiation records none. It yields one event-loop turn

package/docs/usage/CLIENT_API_REFERENCE.md

@@ -1042,7 +1042,10 @@ judgement moved to the caller, who knows which types they are activating.
 
 ### Accept Negotiation
 
-The client can optionally auto-correct `Accept` headers after a 406 response:
+The client can optionally auto-correct `Accept` headers after a 406 response
+(and `Content-Type` after a 415). It is **off** unless switched on, per client
+as below or with `ADT_ACCEPT_CORRECTION=true`; with no switch a `406`/`415` is
+the call's answer and nothing is sent again (default flipped in 35.0.0):
 
 ```typescript
 const client = new AdtClient(connection, console, {

package/docs/usage/MIGRATION-35.md

@@ -0,0 +1,33 @@
+# Migrating to 35.0.0
+
+35.0.0 changes no type and no dependency range. It changes one default.
+
+## Accept negotiation is off unless switched on
+
+Until 34.x, a request SAP answered `406` (its `Accept` not served) or `415`
+(its `Content-Type` not accepted) was corrected from the types SAP named and
+sent once more, unless you turned that off. Now nothing is corrected or sent
+again unless you turn it on: the `406`/`415` is the call's answer, like any
+other status.
+
+- `getAcceptCorrectionEnabled(connection)` is `false` without an explicit
+  switch.
+- `ADT_ACCEPT_CORRECTION=true` turns it on. Only the exact value `true` does;
+  unset, `false` or anything else leaves it off.
+- The `enableAcceptCorrection` option and `setAcceptCorrectionEnabled` are
+  unchanged.
+
+What to do if you relied on the default:
+
+1. Switch it on: `new AdtClient(connection, logger, { enableAcceptCorrection:
+   true })` (the same option on `AdtRuntimeClient`), or set
+   `ADT_ACCEPT_CORRECTION=true`; or
+2. Correct the request yourself. `extractSupportedAccept(error)` returns the
+   media types a `406` names; `rememberAccept(connection, request, accept)`
+   stores the one you choose in the connection's accept cache;
+   `cachedAccept(connection, request)` reads it back. All three are exported
+   from the package root; the last two read and write the cache negotiation
+   itself uses, so a correction made either way serves both.
+
+`cachedAccept` is a plain read of the cache and no longer depends on the switch.
+A batch connection stays exempt from negotiation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/adt-clients",
-  "version": "34.2.0",
+  "version": "35.0.0",
   "description": "ADT clients for SAP ABAP systems - AdtClient and AdtRuntimeClient",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",