@mcp-abap-adt/connection 7.0.0 → 8.0.1

package/CHANGELOG.md

@@ -7,6 +7,83 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [8.0.1] - 2026-09-08
+
+**Documentation only — 7.0.0 and 8.0.0 shipped without their migration note.**
+
+Both majors are already on npm, and `docs/` travels in the tarball, so the
+installed package described the pre-7.0.0 connection: no request id, no
+profiling, no `flushGoodbye`, and no word on what a consumer on 6.x must
+change. This release carries the documentation those two releases owed and
+changes no code.
+
+### Documentation
+
+- `docs/MIGRATION-8.0.md` (new): what a consumer on 6.x does about the
+  `IAdtWireResponse` return of `makeAdtRequest`, the capability atoms the
+  class now declares, and the two headers every request now carries.
+- `docs/STATEFUL_SESSION_GUIDE.md`: the session type is the connection's —
+  `x-sap-adt-sessiontype: stateful` is added by the transport, not by a
+  caller's headers — and `flushGoodbye` is how a caller waits for the
+  goodbye.
+- `README.md` and `docs/INDEX.md` point at both.
+
+## [8.0.0] - 2026-09-08
+
+**A consumer holding the contract can now do what the connection could always do.**
+
+### Changed
+
+- **BREAKING: onto `@mcp-abap-adt/interfaces@^39.0.0`**, from `^21.0.0`.
+  Seventeen majors, and the whole of it was eight compiler errors in one file.
+
+  - `makeAdtRequest` returns `IAdtWireResponse<T, D>`, not `IAdtResponse<T, D>`.
+    The two parted company when `IAdtResponse` became the result-or-failure
+    union a *member* answers, with `E extends IAdtError`; a connection answers
+    the raw HTTP shape, which is what `IAdtWireResponse` is. Six occurrences,
+    all of them the same rename — no behaviour moved.
+  - `isNetworkError` is this package's own again, in `src/utils/networkErrors.ts`.
+    `@mcp-abap-adt/interfaces` published it until 29.0.0, when that package
+    stopped emitting code: it holds types, interfaces and constants, and a
+    predicate is none of those. `NETWORK_ERROR_CODES` is still imported from
+    there — the codes are a constant, the judgement is not.
+
+### Added
+
+- **`flushGoodbye(timeoutMs?)`** — waits for the goodbye `disconnect()`
+  dispatched, within a budget.
+
+  `disconnect()` sends the logoff and does not await it, deliberately: a goodbye
+  carries no request timeout, and a server that never answers must not hold a
+  teardown open. That is right for a teardown and wrong for a reconnect —
+  `disconnect()` then `connect()` opens the next session while the previous
+  one's goodbye is still being assembled, and the server keeps both.
+
+  Measured on E19 through `@mcp-abap-adt/adt-clients`, whose harness recycled
+  the session after each test: a new ABAP session every one to two seconds for a
+  whole run, none released, each living to its own thirty-minute idle timeout.
+
+  The budget bounds the waiting, not the overlap: finishes in time and there is
+  none, does not and the caller proceeds while the goodbye stays outstanding.
+
+- **The connection declares the atoms it honours**: `ICriticalSection`,
+  `IRequestProfiling` and — through 39.0.0's addition to
+  `ISessionLifecycleAware` — `flushGoodbye`.
+
+  All four methods already existed here. What changed is that a consumer can
+  reach them: `AbapConnection` is `IAbapConnection`, so until now
+  `beginCriticalSection()`, `setProfilingRequest()` and `flushGoodbye()` were
+  reachable only by casting to the concrete class, which is the thing the
+  contracts package exists to make unnecessary.
+
+  A test narrows a connection to each atom from the base contract and calls
+  through it. Worth saying what that does and does not check: TypeScript is
+  structural, so removing an atom from the `implements` list changes nothing —
+  the class still has the methods. What the clause buys is the compiler
+  checking the class against the contract: removing `beginCriticalSection`
+  itself is `TS2420`, which is the failure worth having.
+
+
 ## [7.0.0] - 2026-09-08
 
 **Headers that belong to the request stop belonging to the session.**
@@ -1457,7 +1534,9 @@ const connection = createAbapConnection(config, logger);
 - JWT token refresh now properly handles connection errors (401/403 during initial connect)
 - Permission errors (403 with "ExceptionResourceNoAccess") no longer trigger JWT refresh loops
 - Proper separation: base class handles HTTP/session, concrete classes handle auth-specific errors
-[Unreleased]: https://github.com/fr0ster/mcp-abap-connection/compare/v7.0.0...HEAD
+[Unreleased]: https://github.com/fr0ster/mcp-abap-connection/compare/v8.0.1...HEAD
+[8.0.1]: https://github.com/fr0ster/mcp-abap-connection/compare/v8.0.0...v8.0.1
+[8.0.0]: https://github.com/fr0ster/mcp-abap-connection/compare/v7.0.0...v8.0.0
 [7.0.0]: https://github.com/fr0ster/mcp-abap-connection/compare/v6.1.0...v7.0.0
 [6.0.1]: https://github.com/fr0ster/mcp-abap-connection/compare/v6.0.0...v6.0.1
 [6.1.0]: https://github.com/fr0ster/mcp-abap-connection/compare/v6.0.1...v6.1.0

package/README.md

@@ -34,7 +34,9 @@ The package uses a clean separation of concerns:
 
 - **`AbstractAbapConnection`** (abstract, internal only):
   - Common HTTP request logic
-  - Session lifecycle: `connect()` / `disconnect()`, admission, lock windows, teardown draining
+  - Session lifecycle: `connect()` / `disconnect()` / `flushGoodbye()`, admission, lock windows, teardown draining
+  - Capability atoms a consumer narrows to, rather than casting to a connector class:
+    `ISessionLifecycleAware`, `ICriticalSection`, `IRequestProfiling`
   - Session management (cookies, CSRF tokens)
   - CSRF token fetching with retry
   - Auth-agnostic - knows nothing about Basic or JWT

package/dist/connection/AbstractAbapConnection.d.ts

@@ -1,10 +1,10 @@
-import { type IAdtResponse, type ISessionLifecycleAware } from '@mcp-abap-adt/interfaces';
+import { type IAdtWireResponse, type ICriticalSection, type IRequestProfiling, type ISessionLifecycleAware } from '@mcp-abap-adt/interfaces';
 import type { SapConfig } from '../config/sapConfig.js';
 import type { ILogger } from '../logger.js';
 import { SessionLifecycle } from '../session/SessionLifecycle.js';
 import type { AbapConnection, AbapRequestOptions } from './AbapConnection.js';
 import { type IAdtSessionContext, type IAdtTransport } from './IAdtTransport.js';
-declare abstract class AbstractAbapConnection implements AbapConnection, ISessionLifecycleAware {
+declare abstract class AbstractAbapConnection implements AbapConnection, ISessionLifecycleAware, ICriticalSection, IRequestProfiling {
     private readonly config;
     /**
      * Required, and constructed by the caller.
@@ -53,6 +53,21 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * raises the effective timeout to CRITICAL_SECTION_TIMEOUT (a large ceiling)
      * so the request runs to completion instead of being interrupted.
      */
+    /**
+     * The last goodbye this connection dispatched, so a caller can wait for it.
+     *
+     * `disconnect()` sends the logoff without awaiting it, for the reason stated
+     * there. That is right for a teardown and wrong for a caller who is about to
+     * `connect()` again: the next session opens while the previous one's goodbye
+     * is still being assembled, and a caller who recycles in a loop leaves one
+     * abandoned session per iteration. Measured against E19 from
+     * `@mcp-abap-adt/adt-clients`: a session every 1-2 seconds for a whole test
+     * run, none of them released, each surviving to its 30-minute idle timeout.
+     *
+     * Keeping it costs nothing and is the only thing a caller can hold on to —
+     * before this, the promise was created and dropped on the floor.
+     */
+    private goodbye;
     private inCriticalSection;
     /** Reference count for nested beginCriticalSection()/endCriticalSection() pairs. */
     private criticalSectionDepth;
@@ -241,6 +256,22 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * timeout by design.
      */
     disconnect(): Promise<void>;
+    /**
+     * Wait for the last dispatched goodbye, bounded.
+     *
+     * For the caller who ends a session and immediately opens another. Without
+     * it the two overlap and the server keeps both; with it the previous session
+     * is gone — or known not to be going — before the next one is asked for.
+     *
+     * Bounded because the goodbye deliberately carries no request timeout: a
+     * server that never answers must not hold a teardown open, and it must not
+     * hold this open either. On expiry this returns rather than throwing, since
+     * "the goodbye has not arrived yet" is not a failure of the caller's next
+     * step — and the session it addressed will fall to the idle timeout anyway.
+     *
+     * Safe to call at any time: with nothing dispatched it returns immediately.
+     */
+    flushGoodbye(timeoutMs?: number): Promise<void>;
     isConnected(): boolean;
     /**
      * Fingerprint of the SAP-side session, or null when none is known.
@@ -396,7 +427,7 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
     protected sessionFingerprint(): Map<string, string>;
     getBaseUrl(): Promise<string>;
     getAuthHeaders(): Promise<Record<string, string>>;
-    makeAdtRequest<T = any, D = any>(options: AbapRequestOptions): Promise<IAdtResponse<T, D>>;
+    makeAdtRequest<T = any, D = any>(options: AbapRequestOptions): Promise<IAdtWireResponse<T, D>>;
     private performRequest;
     protected abstract buildAuthorizationHeader(): string;
     /**

package/dist/connection/AbstractAbapConnection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/AbstractAbapConnection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AbstractAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/AbstractAbapConnection.ts"],"names":[],"mappings":"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"}

package/dist/connection/AbstractAbapConnection.js

@@ -4,6 +4,7 @@ exports.AbstractAbapConnection = void 0;
 const node_crypto_1 = require("node:crypto");
 const interfaces_1 = require("@mcp-abap-adt/interfaces");
 const SessionLifecycle_js_1 = require("../session/SessionLifecycle.js");
+const networkErrors_js_1 = require("../utils/networkErrors.js");
 const timeouts_js_1 = require("../utils/timeouts.js");
 const csrfConfig_js_1 = require("./csrfConfig.js");
 const IAdtTransport_js_1 = require("./IAdtTransport.js");
@@ -81,6 +82,21 @@ class AbstractAbapConnection {
      * raises the effective timeout to CRITICAL_SECTION_TIMEOUT (a large ceiling)
      * so the request runs to completion instead of being interrupted.
      */
+    /**
+     * The last goodbye this connection dispatched, so a caller can wait for it.
+     *
+     * `disconnect()` sends the logoff without awaiting it, for the reason stated
+     * there. That is right for a teardown and wrong for a caller who is about to
+     * `connect()` again: the next session opens while the previous one's goodbye
+     * is still being assembled, and a caller who recycles in a loop leaves one
+     * abandoned session per iteration. Measured against E19 from
+     * `@mcp-abap-adt/adt-clients`: a session every 1-2 seconds for a whole test
+     * run, none of them released, each surviving to its 30-minute idle timeout.
+     *
+     * Keeping it costs nothing and is the only thing a caller can hold on to —
+     * before this, the promise was created and dropped on the floor.
+     */
+    goodbye = Promise.resolve();
     inCriticalSection = false;
     /** Reference count for nested beginCriticalSection()/endCriticalSection() pairs. */
     criticalSectionDepth = 0;
@@ -350,11 +366,47 @@ class AbstractAbapConnection {
             // The context is taken now, while the session is still true: the clear
             // below runs while the close is suspended on its first await.
             const context = this.sessionContext();
-            const inFlight = Promise.resolve(this.transport.close(context)).then(() => undefined);
+            // Kept, not dropped: `flushGoodbye()` is how a caller who is about to
+            // reconnect waits for it. Rejections are absorbed here so that holding
+            // the promise never turns a failed goodbye into an unhandled rejection —
+            // the transport already logs what went wrong.
+            this.goodbye = Promise.resolve(this.transport.close(context)).then(() => undefined, () => undefined);
             this.clearSessionState();
             this.lifecycle.markDisconnected();
         });
     }
+    /**
+     * Wait for the last dispatched goodbye, bounded.
+     *
+     * For the caller who ends a session and immediately opens another. Without
+     * it the two overlap and the server keeps both; with it the previous session
+     * is gone — or known not to be going — before the next one is asked for.
+     *
+     * Bounded because the goodbye deliberately carries no request timeout: a
+     * server that never answers must not hold a teardown open, and it must not
+     * hold this open either. On expiry this returns rather than throwing, since
+     * "the goodbye has not arrived yet" is not a failure of the caller's next
+     * step — and the session it addressed will fall to the idle timeout anyway.
+     *
+     * Safe to call at any time: with nothing dispatched it returns immediately.
+     */
+    async flushGoodbye(timeoutMs = 5000) {
+        let timer;
+        try {
+            await Promise.race([
+                this.goodbye,
+                new Promise((resolve) => {
+                    timer = setTimeout(resolve, timeoutMs);
+                    // Never hold the process open for a goodbye nobody is waiting on.
+                    timer.unref?.();
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     isConnected() {
         return this.lifecycle.connected;
     }
@@ -927,7 +979,7 @@ class AbstractAbapConnection {
             }
             // Check if this is a network error (connection refused, timeout, DNS, etc.)
             // Don't retry for network errors - these indicate infrastructure/VPN issues
-            const networkError = (0, interfaces_1.isNetworkError)(error);
+            const networkError = (0, networkErrors_js_1.isNetworkError)(error);
             if (networkError) {
                 this.logger?.error(`Network error - cannot connect to SAP system: ${errorDetails.message}`, errorDetails);
                 throw error;

package/dist/utils/networkErrors.d.ts

@@ -0,0 +1,2 @@
+export declare function isNetworkError(error: unknown): boolean;
+//# sourceMappingURL=networkErrors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"networkErrors.d.ts","sourceRoot":"","sources":["../../src/utils/networkErrors.ts"],"names":[],"mappings":"AAkBA,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAItD"}

package/dist/utils/networkErrors.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkError = isNetworkError;
+/**
+ * Whether an error is the network's rather than the server's.
+ *
+ * `@mcp-abap-adt/interfaces` published this as a function until 29.0.0, when
+ * that package stopped emitting code: it holds types, interfaces and constants,
+ * and a predicate is none of those. The codes are still there —
+ * {@link NETWORK_ERROR_CODES} — and the judgement lives here, with the wire it
+ * judges.
+ *
+ * The distinction is not cosmetic. A refusal from SAP is an answer and can be
+ * retried once a token is refreshed; `ECONNREFUSED` is a statement about
+ * infrastructure, and retrying it re-runs the same failure against the same
+ * unreachable host.
+ */
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
+const CODES = new Set(Object.values(interfaces_1.NETWORK_ERROR_CODES));
+function isNetworkError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const code = error.code;
+    return typeof code === 'string' && CODES.has(code);
+}

package/docs/INDEX.md

@@ -15,6 +15,7 @@ mcp-abap-connection/
 │   ├── INSTALLATION.md             # Setup and installation guide
 │   ├── USAGE.md                    # API documentation and examples
 │   ├── MIGRATION-2.0.md            # Moving to the explicit session lifecycle
+│   ├── MIGRATION-8.0.md            # request headers leave the stateful branch; onto interfaces 39; flushGoodbye
 │   ├── MIGRATION-6.0.md            # the factory and the per-credential classes go; RFC is a transport
 │   ├── MIGRATION-4.0.md            # JWT error classification: 401 refreshes, 403 propagates
 │   ├── SCOPE.md                    # What this package does and does not own
@@ -44,6 +45,7 @@ mcp-abap-connection/
 - 🔑 [JWT Auth Tools](./JWT_AUTH_TOOLS.md) - CLI tool for browser-based authentication
 
 ### Upgrading
+- 🚚 [Migrating to 7.0.0 and 8.0.0](./MIGRATION-8.0.md) - `sap-adt-request-id` and `X-sap-adt-profiling` on every request, `x-sap-security-session: use` on cloud, the contracts floor at 39, and `flushGoodbye()`
 - 🚚 [Migrating to 6.0.0](./MIGRATION-6.0.md) - the factory and the per-credential classes are removed; the RFC wire is a transport you hand to the on-prem connector
 - 🧱 [Migrating to 4.0.0](./MIGRATION-4.0.md) - JWT error classification: a 401 refreshes, a 403 propagates with the server's message
 - 🧱 [Migrating to 2.0.0](./MIGRATION-2.0.md) - The explicit session lifecycle: `connect()` is required

package/docs/MIGRATION-6.0.md

@@ -294,7 +294,7 @@ session was negotiated elsewhere:
 ```typescript
 import type { IAuthProvider, IRenewableCredential } from '@mcp-abap-adt/interfaces';
 
-function isRenewable(c: IAuthProvider): c is IRenewableCredential {
+function isRenewable(c: IAuthProvider): c is IAuthProvider & IRenewableCredential {
   return typeof (c as Partial<IRenewableCredential>).renew === 'function';
 }
 ```

package/docs/MIGRATION-8.0.md

@@ -0,0 +1,171 @@
+# Migration to 7.0 and 8.0
+
+Two majors, and **no code of yours has to change for either**. One alters what
+goes on the wire; the other moves the contracts floor and makes methods you
+already had reachable through the types you already hold.
+
+If you build against `@mcp-abap-adt/interfaces` and never cast to a connector
+class, there is nothing to do but install.
+
+## 7.0 — headers that belong to the request stop belonging to the session
+
+Three headers used to be written together, inside the stateful branch:
+
+```ts
+if (this.sessionMode === 'stateful') {
+  requestHeaders['x-sap-adt-sessiontype'] = 'stateful';
+  requestHeaders['sap-adt-request-id'] = randomUUID().replace(/-/g, '');
+  requestHeaders['X-sap-adt-profiling'] = 'server-time';
+}
+```
+
+Only the first belongs there. A request id identifies the **request**, and
+asking the server to report its own processing time is not a property of the
+session either. Eclipse sends both on everything — measured on ADT 3.60.0, a
+stateless source `PUT` carries them and no session type at all.
+
+It stayed invisible while every write ran inside a lock window. Once
+`@mcp-abap-adt/adt-clients` narrowed stateful to the `LOCK` and the `UNLOCK`,
+the writes silently lost two headers: of 792 requests in a full run, 99 carried
+a request id and **693 carried neither**.
+
+### What changed for you
+
+| | |
+|---|---|
+| `sap-adt-request-id` | now on every request, fresh each time |
+| `X-sap-adt-profiling` | now on every request, from a settable default |
+| `x-sap-security-session: use` | **cloud only**, on every request once a session exists |
+| `x-sap-adt-sessiontype` | unchanged — still the only one that varies with the mode |
+
+Nothing in the type surface moved. The major is for the wire: every request
+looks different in an SAP trace, and a system that reacts badly to either should
+be findable by version rather than by reading a dump.
+
+### Your own headers win
+
+Both new headers are **defaults**. A caller who names either in
+`options.headers` keeps their value, matched without case:
+
+```ts
+await conn.makeAdtRequest({
+  url, method: 'GET', timeout: 30_000,
+  headers: { 'sap-adt-request-id': myCorrelationId },   // kept, not replaced
+});
+```
+
+That is not hypothetical: `adt-clients` passes its own id to
+`getDiscovery({ requestId })` so the id it logs is the id on the wire.
+
+### Turning the profiling off
+
+```ts
+conn.setProfilingRequest(null);          // ask for nothing
+conn.setProfilingRequest('server-time'); // the default, and what Eclipse asks for
+```
+
+Nothing in this package reads the `server-time=…` that comes back. An
+investigation does, though — the unit is **microseconds**, which a trial's
+unpublish job settled by answering `server-time=132512547` on a request that
+takes about 133 seconds.
+
+## 8.0 — onto interfaces 39.0.0, and the atoms are declared
+
+### The floor
+
+`@mcp-abap-adt/interfaces` moves from `^21.0.0` to `^39.0.0`. Install it
+alongside; a consumer pinned below 39 cannot have both.
+
+Seventeen majors, and the whole migration inside this package was eight compiler
+errors in one file — `makeAdtRequest` returning `IAdtWireResponse<T, D>` rather
+than `IAdtResponse<T, D>`, and `isNetworkError` coming home because interfaces
+stopped emitting code in 29.0.0.
+
+**If you deduplicate nothing else, deduplicate this.** Two copies of the
+contracts in one graph are structurally identical and do not compare equal, so
+they produce errors that read as impossible.
+
+```
+npm ls @mcp-abap-adt/interfaces     # should print one version, deduped
+```
+
+### `flushGoodbye()` — the half of `disconnect()` that was missing
+
+`disconnect()` dispatches the logoff and does not await it, on purpose: a
+goodbye carries no request timeout, and a server that never answers must not
+hold a teardown open.
+
+That is right for a teardown and wrong for a **reconnect**:
+
+```ts
+await conn.disconnect();
+await conn.flushGoodbye();   // give the goodbye its budget to finish first
+await conn.connect();
+```
+
+Without the middle line, the next session opens while the previous one's goodbye
+is still being assembled and the server keeps both. Measured on E19 through a
+test harness that recycled the session after each test: **a new ABAP session
+every one to two seconds for a whole run, none released**, each living to its
+own thirty-minute idle timeout.
+
+**The budget bounds the waiting, not the overlap.** If the goodbye finishes in
+time there is no overlap; if it does not, you proceed and it stays outstanding
+for as long as it takes. A return is not a confirmation and not even of
+dispatch.
+
+Calling `disconnect()` twice is **not** a substitute — a repeat call does not
+wait either.
+
+### Reaching the controls through the contract
+
+`beginCriticalSection()`, `setProfilingRequest()` and `flushGoodbye()` all
+existed before. What changed is that a consumer can reach them without a cast:
+`AbapConnection` is `IAbapConnection`, and these now live on capability atoms
+that this connection declares.
+
+```ts
+import type {
+  IAbapConnection,
+  ICriticalSection,
+  IRequestProfiling,
+  ISessionLifecycleAware,
+} from '@mcp-abap-adt/interfaces';
+
+function protectTheWindow(conn: IAbapConnection & ICriticalSection) {
+  conn.beginCriticalSection();
+  try {
+    // the ordinary per-request deadline does not apply in here
+  } finally {
+    conn.endCriticalSection();
+  }
+}
+```
+
+`flushGoodbye` is a member of `ISessionLifecycleAware`, not an atom of its own:
+waiting for the goodbye is not a separate capability from sending it.
+
+### One thing to know about `implements`
+
+TypeScript is structural. Removing an atom from a class's `implements` list
+changes nothing for a consumer — the class still has the methods and narrowing
+still succeeds. What the clause buys is the compiler checking the class *against*
+the contract in the other direction: remove `beginCriticalSection` itself and it
+is `TS2420`.
+
+Worth knowing before writing a guard that tests the clause rather than the
+method.
+
+### `IRenewableCredential` is an atom now
+
+Not this package's change, but it lands with the floor. Renewing is something a
+credential can also do, not a kind of credential, so a guard that narrowed to
+`IRenewableCredential` alone now hands the caller something that renews and
+cannot authenticate:
+
+```ts
+// before
+function isRenewable(c: IAuthProvider): c is IRenewableCredential
+// after
+function isRenewable(c: IAuthProvider): c is IAuthProvider & IRenewableCredential
+```

package/docs/STATEFUL_SESSION_GUIDE.md

@@ -120,6 +120,22 @@ authentication answer. A 403 never did this: it is an authorization answer, not
 If you decide the refusal meant a stale token, `renew()` and reconnect are yours to call — and a
 reconnect is a NEW session, so do it outside a lock window rather than inside one.
 
+**Wait for the goodbye before opening the next one.** `disconnect()` dispatches the logoff and does
+not await it, so a reconnect otherwise opens the next session while the previous one's goodbye is
+still being assembled, and the server keeps both:
+
+```typescript
+await conn.disconnect();
+await conn.flushGoodbye();   // give the goodbye its budget to finish first
+await conn.connect();
+```
+
+Measured on E19 through a harness that recycled the session after each test: a new ABAP session
+every one to two seconds for a whole run, none released, each living to its own thirty-minute idle
+timeout. The budget bounds the waiting, not the overlap — if the goodbye finishes in time there is
+none, and if it does not you proceed while it stays outstanding. Calling `disconnect()` again is not
+a substitute: a repeat call does not wait either.
+
 ---
 
 ## Interaction With ADT Clients
@@ -189,6 +205,13 @@ lock is still very much held. That — not any teardown — is why
 `beginCriticalSection()` raises the effective timeout to a large ceiling for the
 duration of a `lock → modify → unlock` chain.
 
+Since 8.0.0 you reach it through the contract rather than the class: it is
+`ICriticalSection` in `@mcp-abap-adt/interfaces`, which this connection declares.
+What it promises is narrow and worth stating exactly — inside a section the
+*ordinary* per-request deadline does not apply. Not that no request can be cut
+short: the ceiling is `SAP_TIMEOUT_CRITICAL`, ten minutes by default, and a
+socket ends a request whatever a contract says.
+
 ### Two sessions, and they are not the same thing
 
 There are two sessions here, and they are not the same thing:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/connection",
-  "version": "7.0.0",
+  "version": "8.0.1",
   "description": "ABAP connection layer for MCP ABAP ADT server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -53,7 +53,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@mcp-abap-adt/interfaces": "^21.0.0",
+    "@mcp-abap-adt/interfaces": "^39.0.0",
     "axios": "^1.16.0",
     "commander": "^14.0.3",
     "open": "^11.0.0"