gremlin 4.0.0-beta.2 → 4.0.0-beta.3

package/build/esm/driver/connection.js

@@ -21,31 +21,40 @@
  */
 import { Buffer } from 'buffer';
 import { EventEmitter } from 'eventemitter3';
-import ioc from '../structure/io/binary/GraphBinary.js';
+import ioc, { createPreciseReader } from '../structure/io/binary/GraphBinary.js';
+import GraphBinaryReader from '../structure/io/binary/internals/GraphBinaryReader.js';
+import StreamReader from '../structure/io/binary/internals/StreamReader.js';
 import * as utils from '../utils.js';
 import ResultSet from './result-set.js';
+import { RequestMessage } from "./request-message.js";
+import { HttpRequest } from './http-request.js';
 import ResponseError from './response-error.js';
 import { Traverser } from '../process/traversal.js';
-const { DeferredPromise } = utils;
-const { graphBinaryReader, graphBinaryWriter } = ioc;
+import { buildDispatcher, httpFetch } from './dispatcher.js';
+import { normalizeLogger } from './logger.js';
 const responseStatusCode = {
     success: 200,
     noContent: 204,
     partialContent: 206,
-    authenticationChallenge: 407,
 };
+/** The default per-request batch size used when neither the request nor the connection sets one. */
+export const DEFAULT_BATCH_SIZE = 64;
 /**
  * Represents a single connection to a Gremlin Server.
  */
 export default class Connection extends EventEmitter {
     url;
     options;
-    _reader;
-    _writer;
+    _responseSerializer;
     isOpen = true;
     traversalSource;
     _enableUserAgentOnConnect;
     _interceptors;
+    _dispatcher;
+    _compression;
+    _batchSize;
+    _bulkResults;
+    _log;
     /**
      * Creates a new instance of {@link Connection}.
      * @param {String} url The resource uri.
@@ -55,16 +64,41 @@ export default class Connection extends EventEmitter {
         super();
         this.url = url;
         this.options = options;
-        this._reader = options.reader || graphBinaryReader;
-        this._writer = 'writer' in options ? options.writer : graphBinaryWriter;
+        this._responseSerializer =
+            options.responseSerializer || (options.preciseNumbers === true ? createPreciseReader() : new GraphBinaryReader(ioc));
+        if (options.pdtRegistry) {
+            this._responseSerializer.pdtRegistry = options.pdtRegistry;
+        }
         this.traversalSource = options.traversalSource || 'g';
         this._enableUserAgentOnConnect = options.enableUserAgentOnConnect !== false;
+        this._log = normalizeLogger(options.logger);
+        if (options.compression === undefined) {
+            this._compression = 'deflate';
+        }
+        else if (options.compression === 'none' || options.compression === 'deflate') {
+            this._compression = options.compression;
+        }
+        else {
+            throw new TypeError(`compression must be 'none' or 'deflate'`);
+        }
+        this._batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+        this._bulkResults = options.bulkResults ?? false;
+        // The driver builds and owns the undici dispatcher from the discrete options.
+        // TLS is configured through the Node/undici runtime (e.g. NODE_EXTRA_CA_CERTS),
+        // not through a driver option.
+        this._dispatcher = buildDispatcher({
+            maxConnections: options.maxConnections,
+            readTimeoutMillis: options.readTimeoutMillis,
+            maxResponseHeaderBytes: options.maxResponseHeaderBytes,
+            keepAliveTimeMillis: options.keepAliveTimeMillis,
+            proxy: options.proxy,
+        });
         const interceptors = options.interceptors;
         if (typeof interceptors === 'function') {
             this._interceptors = [interceptors];
         }
         else if (Array.isArray(interceptors)) {
-            this._interceptors = interceptors;
+            this._interceptors = [...interceptors];
         }
         else if (interceptors === undefined || interceptors === null) {
             this._interceptors = [];
@@ -72,6 +106,24 @@ export default class Connection extends EventEmitter {
         else {
             throw new TypeError('interceptors must be a function, array, or undefined');
         }
+        // Auth interceptor is always last so it runs after user interceptors
+        if (options.auth) {
+            this._interceptors.push(options.auth);
+        }
+        this._log('debug', `Connection created for ${this.url}`);
+    }
+    /**
+     * The connection-level default batch size, used to fill a request's `batchSize` when unset.
+     */
+    get batchSize() {
+        return this._batchSize;
+    }
+    /**
+     * The connection-level default for `bulkResults`, applied to every request unless overridden
+     * per-request. Defaults to `false`.
+     */
+    get bulkResults() {
+        return this._bulkResults;
     }
     /**
      * Opens the connection, if its not already opened.
@@ -81,34 +133,99 @@ export default class Connection extends EventEmitter {
         // No-op for HTTP connections
         return Promise.resolve();
     }
-    /** @override */
-    submit(request) {
-        // The user may not want the body to be serialized if they are using an interceptor.
-        const body = this._writer ? this._writer.writeRequest(request) : request;
-        return this.#makeHttpRequest(body)
-            .then((response) => {
-            return this.#handleResponse(response);
-        });
+    /**
+     * Send a request and buffer the entire response. Returns a Promise<ResultSet>.
+     */
+    async submit(request) {
+        const response = await this.#makeHttpRequest(request);
+        return this.#handleResponse(response);
     }
-    /** @override */
-    stream(request) {
-        throw new Error('stream() is not yet implemented');
+    /**
+     * Send a request and stream the response incrementally.
+     * Returns an AsyncGenerator that yields deserialized result items.
+     * For bulked responses, yields Traverser objects.
+     *
+     * In the GraphBinary v4 streaming protocol, the server sends the status after all
+     * result data. If the server encounters an error mid-traversal, values yielded before
+     * the error are valid partial results. A ResponseError is thrown after the last value
+     * has been yielded.
+     *
+     * @param {RequestMessage} request
+     * @returns {AsyncGenerator<any>}
+     */
+    async *stream(request) {
+        const abortController = new AbortController();
+        let response;
+        try {
+            response = await this.#makeHttpRequest(request, abortController.signal);
+        }
+        catch (e) {
+            throw new Error(`Stream request failed: ${e.message}`, { cause: e });
+        }
+        if (!response.ok) {
+            // For error responses, buffer and parse the error body
+            const buffer = Buffer.from(await response.arrayBuffer());
+            const errorMessage = `Server returned HTTP ${response.status}: ${response.statusText}`;
+            const contentType = response.headers.get("Content-Type");
+            const reader = this.#getReaderForContentType(contentType);
+            try {
+                if (reader) {
+                    const deserialized = await reader.readResponse(buffer);
+                    throw new ResponseError(errorMessage, {
+                        code: deserialized.status.code,
+                        message: deserialized.status.message || response.statusText,
+                        exception: deserialized.status.exception,
+                    });
+                }
+                else if (contentType === 'application/json') {
+                    const errorBody = JSON.parse(buffer.toString());
+                    throw new ResponseError(errorMessage, {
+                        code: response.status,
+                        message: errorBody.message || errorBody.error || response.statusText,
+                    });
+                }
+            }
+            catch (err) {
+                if (err instanceof ResponseError)
+                    throw err;
+            }
+            throw new ResponseError(errorMessage, {
+                code: response.status,
+                message: response.statusText,
+            });
+        }
+        if (!response.body) {
+            // 204 No Content - nothing to yield
+            return;
+        }
+        const streamReader = StreamReader.fromReadableStream(response.body);
+        let completed = false;
+        try {
+            yield* this._responseSerializer.readResponseStream(streamReader);
+            completed = true;
+        }
+        finally {
+            if (!completed) {
+                // Consumer broke out early or an error occurred - abort to release the connection
+                abortController.abort();
+            }
+        }
     }
     #getReaderForContentType(contentType) {
         if (!contentType) {
-            return this._reader;
+            return this._responseSerializer;
         }
-        if (contentType === this._reader.mimeType) {
-            return this._reader;
+        if (contentType === this._responseSerializer.mimeType) {
+            return this._responseSerializer;
         }
         return null;
     }
-    async #makeHttpRequest(body) {
+    async #makeHttpRequest(request, signal) {
         const headers = {
-            'Accept': this._reader.mimeType
+            'Accept': this._responseSerializer.mimeType,
         };
-        if (this._writer) {
-            headers['Content-Type'] = this._writer.mimeType;
+        if (this._compression === 'deflate') {
+            headers['Accept-Encoding'] = 'deflate';
         }
         if (this._enableUserAgentOnConnect) {
             const userAgent = await utils.getUserAgent();
@@ -116,29 +233,35 @@ export default class Connection extends EventEmitter {
                 headers[utils.getUserAgentHeader()] = userAgent;
             }
         }
-        if (this.options.headers) {
-            Object.entries(this.options.headers).forEach(([key, value]) => {
-                headers[key] = Array.isArray(value) ? value.join(', ') : value;
-            });
+        const httpRequest = new HttpRequest('POST', this.url, headers, request);
+        // Promote transactionId to HTTP header before interceptors run.
+        // The field remains in the serialized body as well (dual transmission
+        // per the HTTP transaction protocol specification).
+        if (request instanceof RequestMessage) {
+            const fields = request.getFields();
+            if (fields.has('transactionId')) {
+                httpRequest.headers['X-Transaction-Id'] = fields.get('transactionId');
+            }
         }
-        let httpRequest = {
-            url: this.url,
-            method: 'POST',
-            headers,
-            body,
-        };
         for (let i = 0; i < this._interceptors.length; i++) {
             try {
-                httpRequest = await this._interceptors[i](httpRequest);
+                await this._interceptors[i](httpRequest);
             }
             catch (e) {
                 throw new Error(`Request interceptor at index ${i} failed: ${e.message}`, { cause: e });
             }
         }
-        return fetch(httpRequest.url, {
+        // Auto-serialize body to JSON after interceptors run (idempotent if already serialized)
+        httpRequest.serializeBody();
+        this._log('debug', `Sending ${httpRequest.method} request to ${httpRequest.url}`);
+        return httpFetch.fetch(httpRequest.url, {
             method: httpRequest.method,
             headers: httpRequest.headers,
             body: httpRequest.body,
+            signal,
+            // Node only: the undici dispatcher carries the connection-pool options. In the browser
+            // it is undefined and the field is omitted, letting the user agent manage the transport.
+            ...(this._dispatcher ? { dispatcher: this._dispatcher } : {}),
         });
     }
     async #handleResponse(response) {
@@ -149,16 +272,11 @@ export default class Connection extends EventEmitter {
             const errorMessage = `Server returned HTTP ${response.status}: ${response.statusText}`;
             try {
                 if (reader) {
-                    const deserialized = reader.readResponse(buffer);
-                    const attributes = new Map();
-                    if (deserialized.status.exception) {
-                        attributes.set('exceptions', deserialized.status.exception);
-                        attributes.set('stackTrace', deserialized.status.exception);
-                    }
+                    const deserialized = await reader.readResponse(buffer);
                     throw new ResponseError(errorMessage, {
                         code: deserialized.status.code,
                         message: deserialized.status.message || response.statusText,
-                        attributes: attributes,
+                        exception: deserialized.status.exception,
                     });
                 }
                 else if (contentType === 'application/json') {
@@ -166,7 +284,6 @@ export default class Connection extends EventEmitter {
                     throw new ResponseError(errorMessage, {
                         code: response.status,
                         message: errorBody.message || errorBody.error || response.statusText,
-                        attributes: new Map(),
                     });
                 }
             }
@@ -178,23 +295,17 @@ export default class Connection extends EventEmitter {
             throw new ResponseError(errorMessage, {
                 code: response.status,
                 message: response.statusText,
-                attributes: new Map(),
             });
         }
         if (!reader) {
-            throw new Error(`Response Content-Type '${contentType}' does not match the configured reader (expected '${this._reader.mimeType}')`);
-        }
-        const deserialized = reader.readResponse(buffer);
-        if (deserialized.status.code && deserialized.status.code !== 200 && deserialized.status.code !== 204 && deserialized.status.code !== 206) {
-            const attributes = new Map();
-            if (deserialized.status.exception) {
-                attributes.set('exceptions', deserialized.status.exception);
-                attributes.set('stackTrace', deserialized.status.exception);
-            }
+            throw new Error(`Response Content-Type '${contentType}' does not match the configured response serializer (expected '${this._responseSerializer.mimeType}')`);
+        }
+        const deserialized = await reader.readResponse(buffer);
+        if (deserialized.status.code && deserialized.status.code !== responseStatusCode.success && deserialized.status.code !== responseStatusCode.noContent && deserialized.status.code !== responseStatusCode.partialContent) {
             throw new ResponseError(`Server error: ${deserialized.status.message || 'Unknown error'} (${deserialized.status.code})`, {
                 code: deserialized.status.code,
                 message: deserialized.status.message || '',
-                attributes: attributes,
+                exception: deserialized.status.exception,
             });
         }
         return new ResultSet(deserialized.result.bulked
@@ -205,7 +316,8 @@ export default class Connection extends EventEmitter {
      * Closes the Connection.
      * @return {Promise}
      */
-    close() {
-        return Promise.resolve();
+    async close() {
+        this._log('debug', `Closing connection to ${this.url}`);
+        await this._dispatcher?.close();
     }
 }

package/build/esm/driver/dispatcher.browser.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Browser counterpart of {@link ./dispatcher.ts}. The Node build configures the underlying HTTP
+ * transport through an `undici` dispatcher, but `undici` is built on `node:net`/`node:tls` and
+ * cannot run in a browser. Bundlers pick this file up via the `"browser"` field in `package.json`,
+ * so a browser bundle never imports `undici`.
+ *
+ * The browser's HTTP stack manages the connection-pool options that the Node dispatcher carries,
+ * so {@link buildDispatcher} throws if any is set explicitly (rather than silently ignoring it)
+ * and otherwise returns `undefined`, leaving the connection to issue a plain `fetch`. It is the
+ * only export the connection imports through the swapped `./dispatcher.js` path.
+ */
+/** Transport options accepted by {@link buildDispatcher}; mirrors the Node dispatcher's options. */
+type DispatcherOptions = {
+    maxConnections?: number;
+    readTimeoutMillis?: number;
+    maxResponseHeaderBytes?: number;
+    keepAliveTimeMillis?: number;
+    proxy?: string;
+};
+/**
+ * In the browser there is no `undici` dispatcher, so `fetch` is issued without one and the browser
+ * manages the transport. Any {@link NODE_ONLY_OPTIONS} set explicitly cannot be honored and throws,
+ * so a misconfiguration surfaces immediately instead of being silently dropped. With none set this
+ * returns `undefined` and the connection omits the `dispatcher` field.
+ */
+export declare function buildDispatcher(options?: DispatcherOptions): undefined;
+/**
+ * Browser counterpart of the Node `httpFetch` holder. There is no `undici` in the browser, so
+ * requests use the global `fetch` and the user agent manages the transport. Same holder shape as
+ * the Node build.
+ */
+export declare const httpFetch: {
+    fetch: typeof globalThis.fetch;
+};
+export {};

package/build/esm/driver/dispatcher.browser.js

@@ -0,0 +1,53 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * Connection-pool / transport options that only the Node (`undici`) dispatcher can honor. The
+ * browser's HTTP stack owns these concerns and exposes no `fetch` API to configure them, so they
+ * are rejected here rather than silently ignored. `readTimeoutMillis` is intentionally not in this list:
+ * it has a browser analog (an `AbortSignal`-based timeout) and is handled by the connection.
+ */
+const NODE_ONLY_OPTIONS = [
+    'maxConnections',
+    'keepAliveTimeMillis',
+    'maxResponseHeaderBytes',
+    'proxy',
+];
+/**
+ * In the browser there is no `undici` dispatcher, so `fetch` is issued without one and the browser
+ * manages the transport. Any {@link NODE_ONLY_OPTIONS} set explicitly cannot be honored and throws,
+ * so a misconfiguration surfaces immediately instead of being silently dropped. With none set this
+ * returns `undefined` and the connection omits the `dispatcher` field.
+ */
+export function buildDispatcher(options = {}) {
+    const unsupported = NODE_ONLY_OPTIONS.filter((key) => options[key] !== undefined);
+    if (unsupported.length > 0) {
+        throw new Error(`The following connection options are not supported in the browser and are managed by the ` +
+            `browser's HTTP stack: ${unsupported.join(', ')}. Remove them when running in a browser ` +
+            `(they are supported in Node).`);
+    }
+    return undefined;
+}
+/**
+ * Browser counterpart of the Node `httpFetch` holder. There is no `undici` in the browser, so
+ * requests use the global `fetch` and the user agent manages the transport. Same holder shape as
+ * the Node build.
+ */
+export const httpFetch = {
+    fetch: globalThis.fetch.bind(globalThis),
+};

package/build/esm/driver/dispatcher.d.ts

@@ -0,0 +1,48 @@
+import { Agent, buildConnector, Dispatcher } from 'undici';
+/** Default concurrent-connections-per-origin cap (Node's global fetch is uncapped). */
+export declare const DEFAULT_MAX_CONNECTIONS = 128;
+/** Canonical TinkerPop 4.x default TCP keep-alive idle time (30s), shared across the GLVs. */
+export declare const DEFAULT_KEEP_ALIVE_TIME = 30000;
+/** Options for the default undici {@link Dispatcher}; unset fields use undici defaults. */
+export type DispatcherOptions = {
+    /** Max concurrent connections per origin. Defaults to {@link DEFAULT_MAX_CONNECTIONS}. */
+    maxConnections?: number;
+    /** Read timeout in ms. Maps to undici `headersTimeout` (wait for first response byte) and `bodyTimeout` (idle between body chunks). */
+    readTimeoutMillis?: number;
+    /** Max response header size in bytes. Maps to undici `maxHeaderSize`. */
+    maxResponseHeaderBytes?: number;
+    /** Idle ms before TCP keep-alive probes begin. Defaults to 30s; `0` disables keep-alive. */
+    keepAliveTimeMillis?: number;
+    /** HTTP proxy URI. When set, a {@link ProxyAgent} is built instead of an {@link Agent}. */
+    proxy?: string;
+};
+/**
+ * Resolves the effective keep-alive idle delay: unset falls back to {@link DEFAULT_KEEP_ALIVE_TIME},
+ * a non-positive value disables keep-alive (returns `null`).
+ */
+export declare function resolveKeepAliveTime(keepAliveTime?: number): number | null;
+/**
+ * Builds an undici connector that sets `SO_KEEPALIVE` with the given idle delay on each new socket.
+ * `baseConnector` is parameterised so the wiring can be unit-tested with a fake connector.
+ */
+export declare function buildKeepAliveConnector(delay: number, baseConnector?: ReturnType<typeof buildConnector>): ReturnType<typeof buildConnector>;
+/**
+ * Maps the discrete driver options onto undici {@link Agent.Options} (the single source of truth
+ * for that mapping). Exported as a seam so the mapping can be asserted in unit tests.
+ */
+export declare function buildAgentOptions(options?: DispatcherOptions): Agent.Options;
+/**
+ * Builds the default undici {@link Dispatcher}: a {@link ProxyAgent} when `proxy` is set, otherwise
+ * a plain {@link Agent}. (Agent and ProxyAgent share one dispatcher slot, so only one is built.)
+ */
+export declare function buildDispatcher(options?: DispatcherOptions): Dispatcher;
+/**
+ * HTTP `fetch` for the Node build. Uses undici's own `fetch` (not the global one) so `fetch` and the
+ * {@link buildDispatcher} dispatcher share one undici version, whatever undici the Node runtime
+ * bundles (e.g. Node 26 ships undici 8, incompatible with an undici 6 dispatcher). A holder object,
+ * not a bare export, so tests can swap `fetch` (an ESM export can't be reassigned, an object
+ * property can). The cast aligns undici's `fetch` type with the global one.
+ */
+export declare const httpFetch: {
+    fetch: typeof globalThis.fetch;
+};

package/build/esm/driver/dispatcher.js

@@ -0,0 +1,94 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+import { Agent, ProxyAgent, buildConnector, fetch as undiciFetch } from 'undici';
+/** Default concurrent-connections-per-origin cap (Node's global fetch is uncapped). */
+export const DEFAULT_MAX_CONNECTIONS = 128;
+/** Canonical TinkerPop 4.x default TCP keep-alive idle time (30s), shared across the GLVs. */
+export const DEFAULT_KEEP_ALIVE_TIME = 30000;
+/**
+ * Resolves the effective keep-alive idle delay: unset falls back to {@link DEFAULT_KEEP_ALIVE_TIME},
+ * a non-positive value disables keep-alive (returns `null`).
+ */
+export function resolveKeepAliveTime(keepAliveTime) {
+    const effective = keepAliveTime ?? DEFAULT_KEEP_ALIVE_TIME;
+    return effective > 0 ? effective : null;
+}
+/**
+ * Builds an undici connector that sets `SO_KEEPALIVE` with the given idle delay on each new socket.
+ * `baseConnector` is parameterised so the wiring can be unit-tested with a fake connector.
+ */
+export function buildKeepAliveConnector(delay, baseConnector = buildConnector({})) {
+    return (connectOptions, callback) => {
+        baseConnector(connectOptions, (err, socket) => {
+            if (err) {
+                callback(err, null);
+                return;
+            }
+            if (socket) {
+                socket.setKeepAlive(true, delay);
+            }
+            callback(null, socket);
+        });
+    };
+}
+/**
+ * Maps the discrete driver options onto undici {@link Agent.Options} (the single source of truth
+ * for that mapping). Exported as a seam so the mapping can be asserted in unit tests.
+ */
+export function buildAgentOptions(options = {}) {
+    const maxConnections = options.maxConnections ?? DEFAULT_MAX_CONNECTIONS;
+    const agentOptions = {
+        connections: maxConnections,
+    };
+    // Connect/idle timeouts are intentionally left to undici defaults (the GLV spec marks the JS
+    // connect/idle timeout as N/A), not exposed as driver options.
+    if (options.readTimeoutMillis !== undefined) {
+        agentOptions.headersTimeout = options.readTimeoutMillis;
+        agentOptions.bodyTimeout = options.readTimeoutMillis;
+    }
+    if (options.maxResponseHeaderBytes !== undefined) {
+        agentOptions.maxHeaderSize = options.maxResponseHeaderBytes;
+    }
+    const keepAliveDelay = resolveKeepAliveTime(options.keepAliveTimeMillis);
+    if (keepAliveDelay !== null) {
+        agentOptions.connect = buildKeepAliveConnector(keepAliveDelay);
+    }
+    return agentOptions;
+}
+/**
+ * Builds the default undici {@link Dispatcher}: a {@link ProxyAgent} when `proxy` is set, otherwise
+ * a plain {@link Agent}. (Agent and ProxyAgent share one dispatcher slot, so only one is built.)
+ */
+export function buildDispatcher(options = {}) {
+    const agentOptions = buildAgentOptions(options);
+    if (options.proxy) {
+        return new ProxyAgent({ uri: options.proxy, ...agentOptions });
+    }
+    return new Agent(agentOptions);
+}
+/**
+ * HTTP `fetch` for the Node build. Uses undici's own `fetch` (not the global one) so `fetch` and the
+ * {@link buildDispatcher} dispatcher share one undici version, whatever undici the Node runtime
+ * bundles (e.g. Node 26 ships undici 8, incompatible with an undici 6 dispatcher). A holder object,
+ * not a bare export, so tests can swap `fetch` (an ESM export can't be reassigned, an object
+ * property can). The cast aligns undici's `fetch` type with the global one.
+ */
+export const httpFetch = {
+    fetch: undiciFetch,
+};

package/build/esm/driver/driver-remote-connection.d.ts

@@ -3,27 +3,33 @@
  */
 import * as rcModule from './remote-connection.js';
 declare const RemoteConnection: typeof rcModule.RemoteConnection;
+import Client from './client.js';
 import GremlinLang from '../process/gremlin-lang.js';
 import { ConnectionOptions } from './connection.js';
 /**
  * Represents the default `RemoteConnection` implementation.
  */
 export default class DriverRemoteConnection extends RemoteConnection {
-    private readonly _client;
+    #private;
+    readonly _client: Client;
+    private _transactionId?;
     /**
      * Creates a new instance of {@link DriverRemoteConnection}.
      * @param {String} url The resource uri.
      * @param {ConnectionOptions} [options] The connection options.
+     * @param {String} [transactionId] Optional transaction ID to attach to all requests.
      */
-    constructor(url: string, options?: ConnectionOptions);
+    constructor(url: string, options?: ConnectionOptions, transactionId?: string);
+    /**
+     * Returns the transaction ID if this connection is bound to a transaction, undefined otherwise.
+     */
+    get transactionId(): string | undefined;
     /** @override */
     open(): Promise<void>;
     /** @override */
     get isOpen(): boolean;
     /** @override */
     submit(gremlinLang: GremlinLang): Promise<rcModule.RemoteTraversal>;
-    commit(): Promise<any>;
-    rollback(): Promise<any>;
     close(): Promise<void>;
     /** @override */
     addListener(event: string, handler: (...args: any[]) => unknown): void;