@mcp-abap-adt/connection 3.0.0 → 5.0.0

package/dist/auth/providers.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The credentials a connector can be handed.
+ *
+ * Each is the authentication half of one of the connection classes that used to
+ * carry both halves, lifted out unchanged — the header a `BasicAuthProvider`
+ * builds is byte for byte what `BaseAbapConnection` built, and the TLS options a
+ * `CertificateAuthProvider` returns are what `CertificateAbapConnection`
+ * returned. Nothing about how a credential works changed; only who owns it.
+ */
+import type { AgentOptions } from 'node:https';
+import type { ICertificateMaterialLoader, ISapConfig, ITokenRefresher } from '@mcp-abap-adt/interfaces';
+import type { IAuthProvider } from './IAuthProvider.js';
+/** Username and password, as `Basic base64(user:pass)`. */
+export declare class BasicAuthProvider implements IAuthProvider {
+    private readonly username;
+    private readonly password;
+    readonly kind = "basic";
+    constructor(username: string, password: string);
+    authorizationHeader(): Promise<string>;
+}
+/**
+ * A bearer token, kept current by whoever issued it.
+ *
+ * Takes an `ITokenRefresher` — the contract `@mcp-abap-adt/auth-broker` already
+ * produces and `@mcp-abap-adt/auth-providers` already implements twelve ways.
+ * This package depends on neither: it speaks the contract, and the consumer
+ * brings the implementation, exactly as it does for `IAbapConnection`.
+ *
+ * **This carries no session recovery.** What happens to a session when the
+ * credential behind it is renewed mid-flight is the connection's business and
+ * stays there; see `JwtAbapConnection`, which still owns that machinery.
+ */
+export declare class TokenAuthProvider implements IAuthProvider {
+    private readonly source;
+    readonly kind = "token";
+    /**
+     * A token, or something that can produce one.
+     *
+     * A bare string is a token with no renewal behind it — honest, and fine for a
+     * short task. An `ITokenRefresher` or a function is a provider that checks
+     * expiry and renews on its own, which is where this belongs in a long-lived
+     * process.
+     */
+    constructor(source: string | ITokenRefresher | (() => Promise<string>));
+    /**
+     * Asked every time, and nothing kept.
+     *
+     * The provider behind this already caches the token, knows when it expires,
+     * and renews before handing one back. A second cache here would serve the
+     * stale one and hide exactly the renewal the provider exists to do — which
+     * is what the first version of this class did.
+     */
+    authorizationHeader(): Promise<string>;
+    /**
+     * The token was refused, so force a new one.
+     *
+     * `getToken()` is documented to return the cached token while it believes it
+     * is still valid — which is exactly the situation after a 401 on a token the
+     * provider has not yet noticed is dead. `refreshToken()` is the contract's
+     * answer for that, and this is the only place it is called.
+     */
+    renew(): Promise<void>;
+}
+/**
+ * A SAML session, already negotiated, presented as cookies.
+ *
+ * No `Authorization` header at all — the cookies are the credential, and they
+ * are added by the connection alongside its own.
+ */
+export declare class SamlAuthProvider implements IAuthProvider {
+    private readonly sessionCookies;
+    readonly kind = "saml";
+    constructor(sessionCookies: string);
+    authorizationHeader(): Promise<string>;
+    /** The cookies to present. */
+    cookies(): string;
+}
+/**
+ * Client certificate: the credential lives in the TLS handshake.
+ *
+ * `prepare()` is where the material is read, which is why it exists at all —
+ * building an agent before it is loaded is what used to reject a connect
+ * before a single request went out.
+ */
+export declare class CertificateAuthProvider implements IAuthProvider {
+    private readonly loader;
+    private readonly config;
+    readonly kind = "certificate";
+    private material;
+    constructor(loader: ICertificateMaterialLoader, config: ISapConfig);
+    prepare(): Promise<void>;
+    authorizationHeader(): Promise<string>;
+    httpsAgentOptions(): AgentOptions;
+}
+//# sourceMappingURL=providers.d.ts.map

package/dist/auth/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/auth/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAEV,0BAA0B,EAC1B,UAAU,EACV,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,2DAA2D;AAC3D,qBAAa,iBAAkB,YAAW,aAAa;IAInD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,QAAQ,CAAC,IAAI,WAAW;gBAGL,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;IAG7B,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;CAG7C;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAkB,YAAW,aAAa;IAYnD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXzB,QAAQ,CAAC,IAAI,WAAW;IAExB;;;;;;;OAOG;gBAEgB,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,CAAC,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAG7E;;;;;;;OAOG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAU5C;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ7B;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IAGxC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAF3C,QAAQ,CAAC,IAAI,UAAU;gBAEM,cAAc,EAAE,MAAM;IAE7C,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5C,8BAA8B;IAC9B,OAAO,IAAI,MAAM;CAGlB;AAED;;;;;;GAMG;AACH,qBAAa,uBAAwB,YAAW,aAAa;IAKzD,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,QAAQ,CAAC,IAAI,iBAAiB;IAC9B,OAAO,CAAC,QAAQ,CAAqC;gBAGlC,MAAM,EAAE,0BAA0B,EAClC,MAAM,EAAE,UAAU;IAG/B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAMxB,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5C,iBAAiB,IAAI,YAAY;CASlC"}

package/dist/auth/providers.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * The credentials a connector can be handed.
+ *
+ * Each is the authentication half of one of the connection classes that used to
+ * carry both halves, lifted out unchanged — the header a `BasicAuthProvider`
+ * builds is byte for byte what `BaseAbapConnection` built, and the TLS options a
+ * `CertificateAuthProvider` returns are what `CertificateAbapConnection`
+ * returned. Nothing about how a credential works changed; only who owns it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CertificateAuthProvider = exports.SamlAuthProvider = exports.TokenAuthProvider = exports.BasicAuthProvider = void 0;
+/** Username and password, as `Basic base64(user:pass)`. */
+class BasicAuthProvider {
+    username;
+    password;
+    kind = 'basic';
+    constructor(username, password) {
+        this.username = username;
+        this.password = password;
+    }
+    async authorizationHeader() {
+        return `Basic ${Buffer.from(`${this.username ?? ''}:${this.password ?? ''}`).toString('base64')}`;
+    }
+}
+exports.BasicAuthProvider = BasicAuthProvider;
+/**
+ * A bearer token, kept current by whoever issued it.
+ *
+ * Takes an `ITokenRefresher` — the contract `@mcp-abap-adt/auth-broker` already
+ * produces and `@mcp-abap-adt/auth-providers` already implements twelve ways.
+ * This package depends on neither: it speaks the contract, and the consumer
+ * brings the implementation, exactly as it does for `IAbapConnection`.
+ *
+ * **This carries no session recovery.** What happens to a session when the
+ * credential behind it is renewed mid-flight is the connection's business and
+ * stays there; see `JwtAbapConnection`, which still owns that machinery.
+ */
+class TokenAuthProvider {
+    source;
+    kind = 'token';
+    /**
+     * A token, or something that can produce one.
+     *
+     * A bare string is a token with no renewal behind it — honest, and fine for a
+     * short task. An `ITokenRefresher` or a function is a provider that checks
+     * expiry and renews on its own, which is where this belongs in a long-lived
+     * process.
+     */
+    constructor(source) {
+        this.source = source;
+    }
+    /**
+     * Asked every time, and nothing kept.
+     *
+     * The provider behind this already caches the token, knows when it expires,
+     * and renews before handing one back. A second cache here would serve the
+     * stale one and hide exactly the renewal the provider exists to do — which
+     * is what the first version of this class did.
+     */
+    async authorizationHeader() {
+        const token = typeof this.source === 'string'
+            ? this.source
+            : typeof this.source === 'function'
+                ? await this.source()
+                : await this.source.getToken();
+        return token ? `Bearer ${token}` : '';
+    }
+    /**
+     * The token was refused, so force a new one.
+     *
+     * `getToken()` is documented to return the cached token while it believes it
+     * is still valid — which is exactly the situation after a 401 on a token the
+     * provider has not yet noticed is dead. `refreshToken()` is the contract's
+     * answer for that, and this is the only place it is called.
+     */
+    async renew() {
+        if (typeof this.source === 'string' || typeof this.source === 'function') {
+            // Nothing to force: a fixed token has no source, and a function is asked
+            // afresh every time anyway.
+            return;
+        }
+        await this.source.refreshToken();
+    }
+}
+exports.TokenAuthProvider = TokenAuthProvider;
+/**
+ * A SAML session, already negotiated, presented as cookies.
+ *
+ * No `Authorization` header at all — the cookies are the credential, and they
+ * are added by the connection alongside its own.
+ */
+class SamlAuthProvider {
+    sessionCookies;
+    kind = 'saml';
+    constructor(sessionCookies) {
+        this.sessionCookies = sessionCookies;
+    }
+    async authorizationHeader() {
+        return '';
+    }
+    /** The cookies to present. */
+    cookies() {
+        return this.sessionCookies;
+    }
+}
+exports.SamlAuthProvider = SamlAuthProvider;
+/**
+ * Client certificate: the credential lives in the TLS handshake.
+ *
+ * `prepare()` is where the material is read, which is why it exists at all —
+ * building an agent before it is loaded is what used to reject a connect
+ * before a single request went out.
+ */
+class CertificateAuthProvider {
+    loader;
+    config;
+    kind = 'certificate';
+    material = null;
+    constructor(loader, config) {
+        this.loader = loader;
+        this.config = config;
+    }
+    async prepare() {
+        if (!this.material) {
+            this.material = await this.loader.load(this.config);
+        }
+    }
+    async authorizationHeader() {
+        return '';
+    }
+    httpsAgentOptions() {
+        if (!this.material) {
+            throw new Error('CertificateAuthProvider: certificate material not loaded. connect() prepares it; a request before that has nothing to present.');
+        }
+        const { cert, key, pfx, passphrase } = this.material;
+        return { cert, key, pfx, passphrase };
+    }
+}
+exports.CertificateAuthProvider = CertificateAuthProvider;

package/dist/connection/AbstractAbapConnection.d.ts

@@ -2,12 +2,29 @@ import { type IAdtResponse, type ISessionLifecycleAware } from '@mcp-abap-adt/in
 import type { SapConfig } from '../config/sapConfig.js';
 import type { ILogger } from '../logger.js';
 import { SessionLifecycle } from '../session/SessionLifecycle.js';
+import type { SessionStrategy } from '../session/SessionStrategy.js';
 import type { AbapConnection, AbapRequestOptions } from './AbapConnection.js';
 /**
  * Declares the capabilities explicitly rather than satisfying them by accident.
  * `AbapConnection` is the base contract every transport honours; these two are
  * the HTTP session's own, and naming them means a signature that drifts from
  * the published contract fails to compile here instead of at the consumer.
+ *
+ * **This gives the consumer instruments; it does not decide for it.** `connect()`
+ * opens one session and `disconnect()` closes it. How many connections to hold,
+ * how long to hold them and when to let go stays with the caller — there are no
+ * thresholds here, no pooling and no eviction, because none of that is knowable
+ * from inside a single connection. A session this one did not open is not its
+ * business: the session limit is per user and the pool is shared, so a SAP GUI
+ * logon of the same user sits in the same list.
+ *
+ * **Nothing the server decides is treated as something to count on.** Whether it
+ * issues a session cookie, whether it still holds a session it issued, how many
+ * it will tolerate, how fast it answers a logoff — all of that is its own and
+ * may differ by system and release. So each is observed and reported, never
+ * relied upon: the logoff is best effort under a bound the caller sets, a
+ * missing session cookie is a warning rather than a rule, and no code here
+ * counts sessions or predicts the next answer from the last one.
  */
 declare abstract class AbstractAbapConnection implements AbapConnection, ISessionLifecycleAware {
     private readonly config;
@@ -38,6 +55,53 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
     private inCriticalSection;
     /** Reference count for nested beginCriticalSection()/endCriticalSection() pairs. */
     private criticalSectionDepth;
+    /** The default release deadline, validated once at construction. */
+    private readonly releaseDeadlineMs;
+    /**
+     * The logoff for the session this connection last held, while it is on its
+     * way. One, because a connection holds one session: `connect()` opens it and
+     * `disconnect()` closes it, and how many connections to run is the caller's
+     * business, not something to be tracked here.
+     *
+     * Carries the session id, not just the promise, so a release still in flight
+     * for an EARLIER session is recognised as not being this one's — reusing it
+     * was what left the second session of a reconnect never released at all.
+     *
+     * The id is the `SAP_SESSIONID` value — the ABAP session, the one locks are
+     * bound to — never the cookie header: that header also carries `sap-XSRF_*`,
+     * which rotates within one and the same session, so comparing headers made a
+     * session stop recognising itself after a token refresh.
+     */
+    /**
+     * How this server opens and gives back a session, decided by asking it rather
+     * than by guessing which system it is. Set at establishment; until then the
+     * on-prem mechanism, which is the one that needs no resource.
+     */
+    /**
+     * The application server this session lives on, as the server named it.
+     *
+     * A session belongs to ONE application server. On a multi-node system a
+     * request that lands on another gets another session — and a lock held on the
+     * first is then dead through nobody's fault and no inactivity. Eclipse pins
+     * itself with these headers; without them every request is a fresh throw of
+     * the dice.
+     *
+     * Learned from `sap-adt-saplb` on a response, sent back as `saplb`. Cleared
+     * with the rest of the session state: it names a server for a session that no
+     * longer exists.
+     */
+    private appServer;
+    /**
+     * Whether the preflight opened a session of its own.
+     *
+     * Distinct from "there are cookies": a failed establishment often leaves a
+     * cookie from the 401 that rejected it, and that is debris, not a session.
+     * Only a preflight answered with a session address opened one, and only that
+     * is worth saying goodbye to when establishment then fails.
+     */
+    private preflightOpenedSession;
+    private sessionStrategy;
+    private pendingRelease;
     protected constructor(config: SapConfig, logger: ILogger | null, sessionId?: string, options?: {
         skipSessionType?: boolean;
     });
@@ -97,6 +161,27 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * preparation and fetch the CSRF token; connect() owns everything around it.
      */
     protected abstract establishSession(): Promise<void>;
+    /**
+     * Gets the credential ready before anything is sent.
+     *
+     * A no-op for the auth types whose credential is already in hand — basic
+     * builds a header from the configuration, JWT carries a token it was given.
+     * It exists for the ones that have to fetch or load theirs, because the
+     * preflight now runs BEFORE `establishSession()` and needs a credential to
+     * go out with: a certificate connection reads its material there, and
+     * without this the preflight throws `certificate material not loaded` while
+     * assembling the transport — before a single request is made, on every
+     * system, cloud or on-prem.
+     *
+     * Must be idempotent: `establishSession()` may prepare the same credential
+     * again, and does.
+     *
+     * Kerberos deliberately does NOT implement it. Minting the SPNEGO token this
+     * early changes when the exchange happens, and that connection is not
+     * production-tested — its preflight fails the way it already did, is caught
+     * inside the strategy, and the connection falls back to ICF as before.
+     */
+    protected prepareCredential(): Promise<void>;
     /**
      * Establishes the session, once, under the lifecycle.
      *
@@ -110,18 +195,84 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
     /**
      * Tears the session down. Never throws, and always settles.
      *
-     * It waits for NOTHING. Deciding when to disconnect is the caller's, and so is
-     * preparing for it — finishing chains, releasing locks. Waiting here on a
-     * request whose caller chose no timeout is what made a teardown unbounded, and
-     * an unbounded teardown blocks every later transition on the serialized tail.
+     * Tells the server the session is no longer needed, then clears the local
+     * state. **When the server actually reclaims it is the server's business** —
+     * possibly not until the next connect asks it for one — and nothing here
+     * waits for that or depends on it. What matters is that the session stops
+     * being counted against the user, which dropping the cookie alone does not
+     * achieve: the server keeps it until its own timeout, so a process that
+     * connects repeatedly leaves one behind every time. Measured on S/4HANA on-prem, 25 connects in a row: with the logoff,
+     * 24-25 of them were given a session; without it, 2. A connection that gets
+     * no session still answers `200` to a LOCK and hands back a handle the next
+     * request cannot use, so the leak surfaces as a half-written object rather
+     * than as anything about sessions.
+     *
+     * **The logoff is the only thing waited for**, under `deadlineMs`, and
+     * deciding that bound is the caller's — see the parameter. Nothing else is
+     * waited for: finishing chains and releasing locks stay the caller's to do
+     * before calling, and waiting here on a request whose caller chose no timeout
+     * is what made a teardown unbounded, which blocks every later transition on
+     * the serialized tail.
+     *
+     * **Requests already in flight are not waited for, and the logoff ends the
+     * session they are running on** — so they will start failing against a
+     * session that no longer exists. That is the caller having asked to
+     * disconnect, not a race, and it is a change from the version that only
+     * dropped the cookie. Generation fencing (see `SessionLifecycle.isCurrent`)
+     * keeps their results from reaching this connection either way.
+     *
+     * @param options.deadlineMs How long to spend telling the server, measured
+     *   from this call and including time spent queued behind another transition.
+     *   **Defaults to `SAP_RELEASE_DEADLINE_MS`, which is `0` — do not wait.**
+     *   Waiting is for steps whose successor needs the server to have caught up;
+     *   a teardown has none. The logoff is still sent at `0`, because saying so
+     *   is not conditional on caring when it lands; its outcome is logged when it
+     *   arrives rather than awaited. Pass a positive value to bound a wait you
+     *   have chosen to take. Anything that is not a finite, non-negative number
+     *   is reported and the default used instead — this method is called from a
+     *   `finally`, where throwing would replace the error that sent the caller
+     *   there. The configured default is checked once, at construction, so a
+     *   misconfigured `SAP_RELEASE_DEADLINE_MS` fails before a connection exists
+     *   rather than at every teardown.
+     */
+    disconnect(options?: {
+        deadlineMs?: number;
+    }): Promise<void>;
+    /**
+     * Tells the server this session is no longer needed. Best effort, and the
+     * answer is not depended on: whether and when the server frees it is its own
+     * affair, and this connection does not check afterwards.
+     *
+     * ICF rather than ADT because ADT publishes no such endpoint: its discovery
+     * document lists none on any reachable system — on-prem, cloud, or legacy —
+     * and the ADT logon is the discovery call itself. `/sap/public/bc/icf/logoff`
+     * is the platform's own, and answers `200` while expiring the session cookie.
      *
-     * Requests already in flight run to completion untouched. Generation fencing
-     * (see `SessionLifecycle.isCurrent`) keeps their results from reaching this
-     * connection afterwards.
+     * **One session, this connection's own.** A repeat `connect()` opens a NEW
+     * one, with a new `SAP_SESSIONID`, so an earlier session is not this
+     * connection's business any more: its logoff is already on the wire, or the
+     * system will time it out. Nothing here retries, counts, or keeps a list —
+     * how many connections to run and how carefully stays with the caller.
      *
-     * Sends no ADT session-close — see the design's D2.
+     * **It ends the session, not this object's use of it.** The cookies are the
+     * only thing tying anyone to a session, so a second connection given the same
+     * cookies works in the same ABAP session and can use the locks taken in it —
+     * and this logoff closes that session for all of them at once. Whoever hands
+     * the cookies around owns that decision; this method cannot see the copies.
+     *
+     * Never throws. `disconnect()` must always settle, and a session we could not
+     * close is better than a teardown that does not finish; the local state is
+     * cleared either way.
+     */
+    private releaseServerSession;
+    /**
+     * Waits up to `budgetMs` for a release already on its way, then detaches.
+     *
+     * Detaching, not cancelling: when the budget runs out this stops waiting and
+     * the request carries on to the server. Each caller of `disconnect()` gets
+     * its own, so one caller's patience is never charged to another's.
      */
-    disconnect(): Promise<void>;
+    private awaitReleaseWithin;
     isConnected(): boolean;
     /**
      * Fingerprint of the SAP-side session, or null when none is known.
@@ -131,14 +282,9 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * session cookie. Use {@link isConnected} for connection state.
      *
      * It follows that null → non-null is not a replacement but an identity being
-     * learned; only a CHANGED value means the session was replaced.
+     * learned; only a CHANGED value means the session we had is gone.
      */
     getSessionIdentity(): string | null;
-    /**
-     * Discards the session at a caller's request: cancels queued recoveries and
-     * queues the cleanup rather than tearing down under a live request.
-     */
-    reset(): void;
     /**
      * Re-establishes the session for a request that is recovering from a
      * credential renewal, then lets that request retry.
@@ -166,9 +312,50 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * Shared by connect() and recoverSession() rather than written twice —
      * the two drifted apart once already, and a third caller would drift again.
      */
+    /**
+     * What a session strategy is given: enough to make one request and to prove
+     * the session is ours, and nothing else. It cannot reach session state, so a
+     * strategy can neither mark this connection connected nor tear it down.
+     */
+    private sessionTransport;
+    /**
+     * Ask the server to open a session before the establishing call needs one.
+     *
+     * The strategy is chosen by what the server publishes, not by which system we
+     * believe it to be: ABAP Cloud offers a session resource and issues
+     * `SAP_SESSIONID` to whoever asks for one — with `x-sap-security-session:
+     * create` — while on-prem has no such resource and its session arrives with
+     * the establishing request. Believing cloud simply "issues no SAP_SESSIONID"
+     * is what happens when nobody asks.
+     */
+    /**
+     * Which session management this system uses — decided by the connection, not
+     * discovered by asking.
+     *
+     * On-prem and cloud do not manage sessions the same way, and the two
+     * implementations exist for that reason. On-prem the session arrives with the
+     * establishing request and the platform's ICF logoff gives it back, exactly as
+     * it always has. Cloud opens a session resource and takes it back by DELETE on
+     * the address the server published.
+     *
+     * Probing was tried and is wrong: `/sap/bc/adt/core/http/sessions` answers on
+     * on-prem too — measured on S/4HANA, which publishes both the session resource
+     * and the ICF logoff in the same document — so a probe does not tell the two
+     * systems apart. It only tells whether an endpoint exists, and both have it.
+     */
+    protected createSessionStrategy(): SessionStrategy;
+    private openServerSession;
     private establishAndCommit;
     /** The teardown epoch, for a recovery to capture before it starts. */
     protected get teardownEpoch(): number;
+    /**
+     * Which session the connection is on now.
+     *
+     * Moves whenever the session does. A response that comes back carrying an
+     * older one belongs to a session that has already been replaced, and must not
+     * be acted on as if it said something about the current one.
+     */
+    protected get sessionGeneration(): number;
     /**
      * Raises a session-lost teardown from inside request handling.
      *
@@ -211,6 +398,22 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * happened — on the error path and on every retry response.
      */
     private observeResponse;
+    /**
+     * Take the application server's name from a response, if it named one.
+     *
+     * Only ever set from the server's own answer — never guessed, and never kept
+     * across a teardown.
+     */
+    private rememberAppServer;
+    /**
+     * Headers that keep this connection on the server its session lives on.
+     *
+     * `sap-adt-saplb: fetch` asks the server to name itself — it answers on every
+     * request, so the binding survives a restart that moves us. `saplb` is that
+     * name sent back. `REDISPATCH_ON_SHUTDOWN` is what Eclipse asks for: if the
+     * server is going down, send us elsewhere rather than fail.
+     */
+    private affinityHeaders;
     /**
      * Acts on what a response said about the session identity.
      *
@@ -231,7 +434,7 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
     /**
      * Whether the server is telling us the session it was given no longer exists.
      *
-     * The E19 shape was HTTP 400 with "Session not found", answered in ~60 ms
+     * One on-prem system answered HTTP 400 with "Session not found", answered in ~60 ms
      * with the cookie present — which is why identity comparison cannot see this:
      * the cookie, and therefore the fingerprint, is completely unchanged. The
      * exact match is landscape-specific and is one of the live probes this design
@@ -297,7 +500,9 @@ declare abstract class AbstractAbapConnection implements AbapConnection, ISessio
      * cookies (HTTP 401 on a mutation while a cached token exists). This forces the
      * next request path to fetch a fresh token and a fresh SAP_SESSIONID cookie.
      *
-     * Distinct from reset(): this leaves the axios instance and interceptors in place.
+     * Distinct from disconnect(): this leaves the axios instance and interceptors
+     * in place, and tells the server nothing — it is a request-level repair, not a
+     * teardown.
      */
     private invalidateSession;
     private shouldRetryCsrf;

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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"}