@mcp-abap-adt/adt-clients 33.0.0 → 34.1.0

package/README.md

@@ -1021,6 +1021,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:
 
+- **[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.
 - **[30.x → 31.0.0](docs/usage/MIGRATION-31.md)** — `interfaces-adt` 16 and
@@ -1156,9 +1157,13 @@ activate all objects with one plain `activateObjectsGroup` call. At a debugger
 stop, record step + stack + variables on the attached stateful connection.
 See [domain and debugger examples](docs/usage/BATCH.md).
 
-`execute()` also sends follow-up envelopes for requests recorded during settlement,
-including automatic 406/415 negotiation retries (up to 100 envelopes, then all
-remaining requests reject). Explicit session switches apply to the next recording;
+`execute()` also sends follow-up envelopes for requests member continuations
+record during settlement (up to 100 envelopes, then all remaining requests
+reject). Nothing in a batch is corrected or sent again: a batch connection is
+exempt from accept negotiation, so a part's `401`, `406` or `415` is that call's
+answer, and a `406`/`415` to the envelope reaches `execute()` as it came. The
+connection's own handling of the envelope request — credential renewal, CSRF
+recovery, session — stays. Explicit session switches apply to the next recording;
 LOCK/UNLOCK run in stateful envelopes; other ordinary members run stateless.
 Consecutive LOCKs, consecutive UNLOCKs, and consecutive stateless requests each
 form separate envelopes sent in queue order.

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;AAK9D,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;IAQH,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;CA6F3C"}
+{"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"}

package/dist/batch/AdtBatchConnection.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdtBatchConnection = void 0;
 const objects_1 = require("../endpoints/objects");
+const acceptNegotiation_1 = require("../utils/acceptNegotiation");
 const adtResponse_1 = require("../utils/adtResponse");
 const wire_1 = require("./wire");
 /** Records member requests; execute also drains requests queued during settlement. */
@@ -21,6 +22,9 @@ class AdtBatchConnection {
         this.defaultSession =
             options.endpoint === 'debugger' ? 'stateful' : 'stateless';
         this.session = this.defaultSession;
+        // What SAP answers to a recorded request is the caller's: no member's
+        // accept negotiation corrects or resends through this connection.
+        (0, acceptNegotiation_1.exemptFromAcceptNegotiation)(this);
     }
     wrappedSession() {
         const connection = this.connection;
@@ -103,7 +107,11 @@ class AdtBatchConnection {
                     endpoint: this.options.endpoint,
                     parts: active.length,
                 });
-                response = await this.connection.makeAdtRequest({
+                // Not through accept negotiation: when an `AdtClient` wrapped the
+                // connection, it would answer a 406/415 to the envelope by sending it
+                // again. A batch is the caller's, and so is what SAP answered to it.
+                // The connection's own handling (credential, CSRF, session) stays.
+                response = await (0, acceptNegotiation_1.getBaseRequest)(this.connection)({
                     url: objects_1.BATCH[this.options.endpoint],
                     method: 'POST',
                     timeout: 0,
@@ -126,7 +134,7 @@ class AdtBatchConnection {
                 if (parts.length !== active.length)
                     throw new Error(`ADT batch response part count mismatch: expected ${active.length}, received ${parts.length}`);
                 active = [];
-                // Let negotiation and member continuations record their follow-up calls.
+                // Let member continuations record their follow-up calls.
                 await new Promise((resolve) => setImmediate(resolve));
                 pending.push(...this.queue.splice(0));
                 if (!pending.length)

package/dist/index.d.ts

@@ -26,4 +26,5 @@ export * from './index.executors';
 export * from './index.readings';
 export * from './index.runtime';
 export * from './index.ws';
+export { exemptFromAcceptNegotiation } 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"}
+{"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,EAAE,2BAA2B,EAAE,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.CT_INCLUDE = exports.AdtInclude = exports.AdtBatchConnection = void 0;
+exports.exemptFromAcceptNegotiation = 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");
@@ -46,3 +46,5 @@ __exportStar(require("./index.executors"), exports);
 __exportStar(require("./index.readings"), exports);
 __exportStar(require("./index.runtime"), exports);
 __exportStar(require("./index.ws"), exports);
+var acceptNegotiation_1 = require("./utils/acceptNegotiation");
+Object.defineProperty(exports, "exemptFromAcceptNegotiation", { enumerable: true, get: function () { return acceptNegotiation_1.exemptFromAcceptNegotiation; } });

package/dist/utils/acceptNegotiation.d.ts

@@ -1,5 +1,14 @@
 import type { IAbapConnection, IAbapRequestOptions, IAdtWireResponse } from '@mcp-abap-adt/interfaces-adt-connection';
 import type { ILogger } from '@mcp-abap-adt/interfaces-utils';
+/**
+ * Mark a connection so accept negotiation never corrects or resends through it.
+ *
+ * Public for a consumer that hands members its own connection over an
+ * `AdtBatchConnection` — a per-call wrapper, say: an `AdtBatchConnection` marks
+ * itself, but a different object is not it, and is negotiated like any other
+ * connection unless it is marked too. The mark is permanent; there is no unmark.
+ */
+export declare function exemptFromAcceptNegotiation(connection: IAbapConnection): void;
 export interface IAcceptNegotiationOptions {
     enableAcceptCorrection?: boolean;
     logger?: ILogger;
@@ -12,6 +21,15 @@ export declare function setAcceptCorrectionEnabled(connection: IAbapConnection,
 export declare function getAcceptCorrectionEnabled(connection: IAbapConnection): boolean;
 export declare function extractSupportedAccept(error: unknown): string[];
 export declare function extractSupportedContentType(error: unknown): string[];
+/**
+ * The connection's request as it was before an `AdtClient` with correction on
+ * wrapped it: accept negotiation corrects and resends nothing. The
+ * connection's own handling (credential, CSRF, session) is untouched.
+ *
+ * Exported for the batch connection: what SAP answers to an envelope is the
+ * caller's to read.
+ */
+export declare function getBaseRequest(connection: IAbapConnection): IAbapConnection['makeAdtRequest'];
 export declare function wrapConnectionAcceptNegotiation(connection: IAbapConnection, logger?: ILogger): void;
 export declare function makeAdtRequestWithAcceptNegotiation<T = unknown, D = unknown>(connection: IAbapConnection, request: IAbapRequestOptions, options?: IAcceptNegotiationOptions): Promise<IAdtWireResponse<T, D>>;
 //# sourceMappingURL=acceptNegotiation.d.ts.map

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;AA6C9D,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;AAcD,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,CA+EjC"}
+{"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;;;;;;;GAOG;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

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.exemptFromAcceptNegotiation = exemptFromAcceptNegotiation;
 exports.clearAcceptCache = clearAcceptCache;
 exports.setAcceptCorrectionEnabled = setAcceptCorrectionEnabled;
 exports.getAcceptCorrectionEnabled = getAcceptCorrectionEnabled;
 exports.extractSupportedAccept = extractSupportedAccept;
 exports.extractSupportedContentType = extractSupportedContentType;
+exports.getBaseRequest = getBaseRequest;
 exports.wrapConnectionAcceptNegotiation = wrapConnectionAcceptNegotiation;
 exports.makeAdtRequestWithAcceptNegotiation = makeAdtRequestWithAcceptNegotiation;
 const STATE = Symbol.for('@mcp-abap-adt/adt-clients/acceptNegotiation');
@@ -21,6 +23,31 @@ function stateOf(connection) {
     }
     return state;
 }
+/**
+ * The mark of a connection accept negotiation never touches: a recording batch
+ * connection. What SAP answers to a recorded request — a `406`/`415` included —
+ * is the batch caller's to read, so nothing is corrected, cached or sent again,
+ * whatever switch an `AdtClient` built over it was given.
+ */
+const NO_NEGOTIATION = Symbol.for('@mcp-abap-adt/adt-clients/acceptNegotiation/none');
+/**
+ * Mark a connection so accept negotiation never corrects or resends through it.
+ *
+ * Public for a consumer that hands members its own connection over an
+ * `AdtBatchConnection` — a per-call wrapper, say: an `AdtBatchConnection` marks
+ * itself, but a different object is not it, and is negotiated like any other
+ * connection unless it is marked too. The mark is permanent; there is no unmark.
+ */
+function exemptFromAcceptNegotiation(connection) {
+    Object.defineProperty(connection, NO_NEGOTIATION, {
+        value: true,
+        enumerable: false,
+        configurable: false,
+    });
+}
+function isExempt(connection) {
+    return (connection[NO_NEGOTIATION] === true);
+}
 const baseRequestMap = new WeakMap();
 /** Forget what this connection learned. */
 function clearAcceptCache(connection) {
@@ -107,11 +134,19 @@ function extractSupportedContentType(error) {
 function buildCacheKey(request) {
     return `${request.method.toUpperCase()} ${request.url}`;
 }
+/**
+ * The connection's request as it was before an `AdtClient` with correction on
+ * wrapped it: accept negotiation corrects and resends nothing. The
+ * connection's own handling (credential, CSRF, session) is untouched.
+ *
+ * Exported for the batch connection: what SAP answers to an envelope is the
+ * caller's to read.
+ */
 function getBaseRequest(connection) {
     return (baseRequestMap.get(connection) ?? connection.makeAdtRequest.bind(connection));
 }
 function wrapConnectionAcceptNegotiation(connection, logger) {
-    if (baseRequestMap.has(connection)) {
+    if (baseRequestMap.has(connection) || isExempt(connection)) {
         return;
     }
     const baseRequest = connection.makeAdtRequest.bind(connection);
@@ -121,6 +156,9 @@ function wrapConnectionAcceptNegotiation(connection, logger) {
     };
 }
 async function makeAdtRequestWithAcceptNegotiation(connection, request, options) {
+    if (isExempt(connection)) {
+        return getBaseRequest(connection)(request);
+    }
     const enableCorrection = options?.enableAcceptCorrection ?? getAcceptCorrectionEnabled(connection);
     const { accept: acceptCache, contentType: contentTypeCache } = stateOf(connection);
     const logger = options?.logger;

package/docs/usage/BATCH.md

@@ -73,6 +73,22 @@ 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
+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
+correction on, a `406` or `415` answered to the envelope reaches `execute()` and
+every part of that envelope as it came. A part's own `401`, `406` or `415` is
+that part's answer like any other status; nothing reads it, corrects it or
+sends it again. A connection of your own that members send through instead of
+the batch connection — a per-call wrapper over it, say — is a different object
+and is negotiated like any other; mark it with `exemptFromAcceptNegotiation(wrapper)`
+(exported by the package) and it is exempt too. 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,
+not about what the parts answered.
+
 At an attached debugger stop, use the attached connection and its stateful session:
 
 ```typescript
@@ -103,8 +119,8 @@ parts in the failed envelope. 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
 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,
-including the automatic 406/415 corrected retry. It yields one event-loop turn
+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
 after settling each envelope to let member continuations record requests. It
 returns the last outer response once that queue is empty. A limit of 100 envelopes
 rejects execution and all remaining requests rather than looping forever.
@@ -121,7 +137,7 @@ For ordinary client members, LOCK and UNLOCK run stateful; creates, writes, read
 and deletes run stateless. Group creates before locks, and writes before unlocks,
 to avoid one envelope per alternating request. One execute can send several
 envelopes and provides no transaction across them. Inner HTTP failures remain
-per-part failures and do not stop later runs, allowing negotiation retries.
+per-part failures and do not stop later runs.
 
 Stateful parts carry `X-sap-adt-sessiontype: stateful`. The wrapped session mode
 is restored afterward. Connections exposing `getSessionMode()` or

package/docs/usage/MIGRATION-34.md

@@ -0,0 +1,32 @@
+# Migrating to 34.0.0
+
+34.0.0 changes no type and no dependency range. It changes what a batch does
+with a `406` or `415`.
+
+## A batch corrects and resends nothing
+
+Until 33.x, a member recorded through `AdtBatchConnection` kept accept
+negotiation: a part SAP answered `406` (its `Accept` not served) or `415` (its
+`Content-Type` not accepted) was corrected from the supported types SAP named
+and recorded again, and `execute()` sent it in a follow-up envelope. The call
+resolved with the corrected request's answer, and SAP's `406`/`415` was gone.
+
+Now a batch connection is exempt from accept negotiation:
+
+- a part's `406` or `415` is that call's answer, a failure carrying SAP's
+  response, like any other status;
+- an `AdtClient` built over a batch connection does not wrap it, whatever
+  `enableAcceptCorrection` it is given, and a member that negotiates by itself
+  sends through it once;
+- a `406`/`415` answered to the envelope itself, on a connection an `AdtClient`
+  wrapped with correction on, reaches `execute()` and the envelope's parts as it
+  came; the envelope is not sent again.
+
+A batch is yours: read each answer and decide what to send again, in a batch of
+your own. The supported types are in the failure's `response` (headers and
+body), where accept negotiation used to read them.
+
+The connection's own handling of the envelope request — credential renewal,
+CSRF recovery, session — is unchanged.
+
+Outside a batch nothing changes: accept negotiation works as before.

package/package.json

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