eventsourcingdb 1.9.0 → 1.10.0

package/dist/Event.js

@@ -1,4 +1,16 @@
 import crypto from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+import { HashVerificationFailedError } from './HashVerificationFailedError.js';
+import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
+import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
+// A hash of version 2 starts with this prefix. A hash without a prefix is of
+// version 1, which predates the prefix.
+const hashVersion2Prefix = 'esdb:hash:v2:';
+const hashVersionRegex = /^esdb:hash:(?<version>[^:]*):/u;
+// The input of a hash of version 2 writes a field that the event does not
+// have like this.
+const missingField = '-';
+const getSha256 = (input) => crypto.createHash('sha256').update(input).digest('hex');
 class Event {
     specversion;
     id;
@@ -9,12 +21,13 @@ class Event {
     type;
     datacontenttype;
     data;
+    #dataFromServer;
     hash;
     predecessorhash;
     traceparent;
     tracestate;
     signature;
-    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, hash, predecessorhash, traceparent, tracestate, signature, }) {
+    constructor({ specversion, id, time, timeFromServer, source, subject, type, datacontenttype, data, dataFromServer, hash, predecessorhash, traceparent, tracestate, signature, }) {
         this.specversion = specversion;
         this.id = id;
         this.time = time;
@@ -24,22 +37,56 @@ class Event {
         this.type = type;
         this.datacontenttype = datacontenttype;
         this.data = data;
+        this.#dataFromServer = dataFromServer;
         this.hash = hash;
         this.predecessorhash = predecessorhash;
         this.traceparent = traceparent;
         this.tracestate = tracestate;
         this.signature = signature;
     }
-    verifyHash() {
+    #computeHashOfVersion1() {
         const metadata = `${this.specversion}|${this.id}|${this.predecessorhash}|${this.#timeFromServer}|${this.source}|${this.subject}|${this.type}|${this.datacontenttype}`;
-        const metadataHash = crypto.createHash('sha256').update(metadata).digest('hex');
-        const dataHash = crypto.createHash('sha256').update(JSON.stringify(this.data)).digest('hex');
-        const finalHash = crypto
-            .createHash('sha256')
-            .update(`${metadataHash}${dataHash}`)
-            .digest('hex');
-        if (finalHash !== this.hash) {
-            throw new Error('Failed to verify hash.');
+        const metadataHash = getSha256(metadata);
+        const dataHash = getSha256(this.#dataFromServer);
+        return getSha256(`${metadataHash}${dataHash}`);
+    }
+    #computeHashOfVersion2() {
+        const input = [
+            hashVersion2Prefix,
+            this.specversion,
+            this.id,
+            this.predecessorhash,
+            this.#timeFromServer,
+            this.source,
+            this.subject,
+            this.type,
+            this.datacontenttype,
+            this.traceparent ?? missingField,
+            this.tracestate ?? missingField,
+            this.#dataFromServer,
+        ].join('\n');
+        return `${hashVersion2Prefix}${getSha256(input)}`;
+    }
+    // An event keeps the version of the hash it was written with, so the hash
+    // is computed in the version it names.
+    #computeHash() {
+        const version = hashVersionRegex.exec(this.hash)?.groups?.version;
+        if (version === undefined) {
+            return this.#computeHashOfVersion1();
+        }
+        if (`esdb:hash:${version}:` === hashVersion2Prefix) {
+            return this.#computeHashOfVersion2();
+        }
+        throw new UnsupportedHashVersionError(version);
+    }
+    verifyHash() {
+        if (this.#computeHash() !== this.hash) {
+            throw new HashVerificationFailedError();
+        }
+        // The hash covers the data as the server sent it, so data that has been
+        // changed since would go unnoticed without comparing the two.
+        if (!isDeepStrictEqual(this.data, JSON.parse(this.#dataFromServer))) {
+            throw new HashVerificationFailedError();
         }
     }
     verifySignature(verificationKey) {
@@ -56,7 +103,7 @@ class Event {
         const hashBytes = Buffer.from(this.hash, 'utf8');
         const isSignatureValid = crypto.verify(null, hashBytes, verificationKey, signatureBytes);
         if (!isSignatureValid) {
-            throw new Error('Signature verification failed.');
+            throw new SignatureVerificationFailedError();
         }
     }
 }

package/dist/HashVerificationFailedError.d.ts

@@ -0,0 +1,4 @@
+declare class HashVerificationFailedError extends Error {
+    constructor();
+}
+export { HashVerificationFailedError };

package/dist/HashVerificationFailedError.js

@@ -0,0 +1,7 @@
+class HashVerificationFailedError extends Error {
+    constructor() {
+        super('Failed to verify hash.');
+        this.name = 'HashVerificationFailedError';
+    }
+}
+export { HashVerificationFailedError };

package/dist/HeartbeatTimeoutError.d.ts

@@ -1,4 +1,4 @@
 declare class HeartbeatTimeoutError extends Error {
-    constructor();
+    constructor(stallTimeout?: number);
 }
 export { HeartbeatTimeoutError };

package/dist/HeartbeatTimeoutError.js

@@ -1,6 +1,8 @@
+import { defaultStallTimeout } from './stall/defaultStallTimeout.js';
+import { formatDuration } from './stall/formatDuration.js';
 class HeartbeatTimeoutError extends Error {
-    constructor() {
-        super('No event and no heartbeat arrived for 30 seconds.');
+    constructor(stallTimeout = defaultStallTimeout) {
+        super(`No event and no heartbeat arrived for ${formatDuration(stallTimeout)}.`);
         this.name = 'HeartbeatTimeoutError';
     }
 }

package/dist/SignatureVerificationFailedError.d.ts

@@ -0,0 +1,4 @@
+declare class SignatureVerificationFailedError extends Error {
+    constructor();
+}
+export { SignatureVerificationFailedError };

package/dist/SignatureVerificationFailedError.js

@@ -0,0 +1,7 @@
+class SignatureVerificationFailedError extends Error {
+    constructor() {
+        super('Signature verification failed.');
+        this.name = 'SignatureVerificationFailedError';
+    }
+}
+export { SignatureVerificationFailedError };

package/dist/UnsupportedHashVersionError.d.ts

@@ -0,0 +1,4 @@
+declare class UnsupportedHashVersionError extends Error {
+    constructor(version: string);
+}
+export { UnsupportedHashVersionError };

package/dist/UnsupportedHashVersionError.js

@@ -0,0 +1,7 @@
+class UnsupportedHashVersionError extends Error {
+    constructor(version) {
+        super(`Hash version '${version}' is not supported.`);
+        this.name = 'UnsupportedHashVersionError';
+    }
+}
+export { UnsupportedHashVersionError };

package/dist/convertCloudEventToEvent.d.ts

@@ -1,4 +1,4 @@
 import type { CloudEvent } from './CloudEvent.js';
 import { Event } from './Event.js';
-declare const convertCloudEventToEvent: (cloudEvent: CloudEvent) => Event;
+declare const convertCloudEventToEvent: (cloudEvent: CloudEvent, cloudEventText?: string) => Event;
 export { convertCloudEventToEvent };

package/dist/convertCloudEventToEvent.js

@@ -1,5 +1,8 @@
 import { Event } from './Event.js';
-const convertCloudEventToEvent = (cloudEvent) => new Event({
+import { getRawJsonMember } from './json/getRawJsonMember.js';
+// The hash of an event covers its data exactly as the server sent it, so the
+// event keeps the data from the text of the cloud event, byte for byte.
+const convertCloudEventToEvent = (cloudEvent, cloudEventText) => new Event({
     specversion: cloudEvent.specversion,
     id: cloudEvent.id,
     time: new Date(cloudEvent.time),
@@ -9,6 +12,8 @@ const convertCloudEventToEvent = (cloudEvent) => new Event({
     type: cloudEvent.type,
     datacontenttype: cloudEvent.datacontenttype,
     data: cloudEvent.data,
+    dataFromServer: (cloudEventText === undefined ? undefined : getRawJsonMember(cloudEventText, 'data')) ??
+        JSON.stringify(cloudEvent.data),
     hash: cloudEvent.hash,
     predecessorhash: cloudEvent.predecessorhash,
     traceparent: cloudEvent.traceparent,

package/dist/getImageTag.d.ts

@@ -0,0 +1,2 @@
+declare const getImageTag: () => string;
+export { getImageTag };

package/dist/getImageTag.js

@@ -0,0 +1,13 @@
+import process from 'node:process';
+import { getImageVersionFromDockerfile } from './getImageVersionFromDockerfile.js';
+// The tests run against the image tag that EVENTSOURCINGDB_IMAGE_TAG names, so
+// that the pipeline can run them against several tags. Without the variable,
+// they run against the tag that the Dockerfile names.
+const getImageTag = () => {
+    const imageTag = process.env.EVENTSOURCINGDB_IMAGE_TAG;
+    if (imageTag !== undefined && imageTag !== '') {
+        return imageTag;
+    }
+    return getImageVersionFromDockerfile();
+};
+export { getImageTag };

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 import { Client } from './Client.js';
+import type { ClientOptions } from './ClientOptions.js';
+import { ConnectionStalledError } from './ConnectionStalledError.js';
 import { Container } from './Container.js';
 import type { Event } from './Event.js';
 import type { EventCandidate } from './EventCandidate.js';
 import type { EventType } from './EventType.js';
+import { HashVerificationFailedError } from './HashVerificationFailedError.js';
 import { HeartbeatTimeoutError } from './HeartbeatTimeoutError.js';
 import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
 import { isSubjectOnEventId } from './isSubjectOnEventId.js';
@@ -11,5 +14,7 @@ import { isSubjectPristine } from './isSubjectPristine.js';
 import type { ObserveEventsOptions } from './ObserveEventsOptions.js';
 import type { Precondition } from './Precondition.js';
 import type { ReadEventsOptions } from './ReadEventsOptions.js';
-export type { Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, };
-export { Client, Container, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, };
+import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
+import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
+export type { ClientOptions, Event, EventCandidate, EventType, ObserveEventsOptions, Precondition, ReadEventsOptions, };
+export { Client, ConnectionStalledError, Container, HashVerificationFailedError, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, SignatureVerificationFailedError, UnsupportedHashVersionError, };

package/dist/index.js

@@ -1,8 +1,12 @@
 import { Client } from './Client.js';
+import { ConnectionStalledError } from './ConnectionStalledError.js';
 import { Container } from './Container.js';
+import { HashVerificationFailedError } from './HashVerificationFailedError.js';
 import { HeartbeatTimeoutError } from './HeartbeatTimeoutError.js';
 import { isEventQlQueryTrue } from './isEventQlQueryTrue.js';
 import { isSubjectOnEventId } from './isSubjectOnEventId.js';
 import { isSubjectPopulated } from './isSubjectPopulated.js';
 import { isSubjectPristine } from './isSubjectPristine.js';
-export { Client, Container, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, };
+import { SignatureVerificationFailedError } from './SignatureVerificationFailedError.js';
+import { UnsupportedHashVersionError } from './UnsupportedHashVersionError.js';
+export { Client, ConnectionStalledError, Container, HashVerificationFailedError, HeartbeatTimeoutError, isEventQlQueryTrue, isSubjectOnEventId, isSubjectPopulated, isSubjectPristine, SignatureVerificationFailedError, UnsupportedHashVersionError, };

package/dist/json/getRawJsonElements.d.ts

@@ -0,0 +1,2 @@
+declare const getRawJsonElements: (text: string) => string[];
+export { getRawJsonElements };

package/dist/json/getRawJsonElements.js

@@ -0,0 +1,22 @@
+import { scanJsonValue, skipJsonWhitespace } from './scanJson.js';
+// Returns the elements of a JSON array exactly as the text contains them, or
+// an empty array if the text is not an array.
+const getRawJsonElements = (text) => {
+    const elements = [];
+    let position = skipJsonWhitespace(text, 0);
+    if (text[position] !== '[') {
+        return elements;
+    }
+    position = skipJsonWhitespace(text, position + 1);
+    while (position < text.length && text[position] !== ']') {
+        const elementEnd = scanJsonValue(text, position);
+        elements.push(text.slice(position, elementEnd));
+        position = skipJsonWhitespace(text, elementEnd);
+        if (text[position] !== ',') {
+            break;
+        }
+        position = skipJsonWhitespace(text, position + 1);
+    }
+    return elements;
+};
+export { getRawJsonElements };

package/dist/json/getRawJsonMember.d.ts

@@ -0,0 +1,2 @@
+declare const getRawJsonMember: (text: string, key: string) => string | undefined;
+export { getRawJsonMember };

package/dist/json/getRawJsonMember.js

@@ -0,0 +1,29 @@
+import { scanJsonString, scanJsonValue, skipJsonWhitespace } from './scanJson.js';
+// Returns the value of a member of a JSON object exactly as the text contains
+// it, or undefined if the text is not an object or has no such member. If the
+// object has the member more than once, the last one wins, as with JSON.parse.
+const getRawJsonMember = (text, key) => {
+    let position = skipJsonWhitespace(text, 0);
+    if (text[position] !== '{') {
+        return;
+    }
+    position = skipJsonWhitespace(text, position + 1);
+    let rawValue;
+    while (text[position] === '"') {
+        const keyEnd = scanJsonString(text, position);
+        const currentKey = JSON.parse(text.slice(position, keyEnd));
+        const colon = skipJsonWhitespace(text, keyEnd);
+        const valueStart = skipJsonWhitespace(text, colon + 1);
+        const valueEnd = scanJsonValue(text, valueStart);
+        if (currentKey === key) {
+            rawValue = text.slice(valueStart, valueEnd);
+        }
+        position = skipJsonWhitespace(text, valueEnd);
+        if (text[position] !== ',') {
+            break;
+        }
+        position = skipJsonWhitespace(text, position + 1);
+    }
+    return rawValue;
+};
+export { getRawJsonMember };

package/dist/json/scanJson.d.ts

@@ -0,0 +1,4 @@
+declare const skipJsonWhitespace: (text: string, start: number) => number;
+declare const scanJsonString: (text: string, start: number) => number;
+declare const scanJsonValue: (text: string, start: number) => number;
+export { scanJsonString, scanJsonValue, skipJsonWhitespace };

package/dist/json/scanJson.js

@@ -0,0 +1,65 @@
+// These functions find where a value starts and ends in a JSON text, so that
+// the SDK can take a value exactly as the server sent it, byte for byte. They
+// expect valid JSON, since the SDK only scans texts that JSON.parse accepted.
+const isJsonWhitespace = (character) => character === ' ' || character === '\t' || character === '\n' || character === '\r';
+const isJsonDelimiter = (character) => character === ',' || character === '}' || character === ']' || isJsonWhitespace(character);
+const skipJsonWhitespace = (text, start) => {
+    let position = start;
+    while (isJsonWhitespace(text[position])) {
+        position += 1;
+    }
+    return position;
+};
+const scanJsonString = (text, start) => {
+    let position = start + 1;
+    while (position < text.length) {
+        const character = text[position];
+        if (character === '\\') {
+            position += 2;
+            continue;
+        }
+        if (character === '"') {
+            return position + 1;
+        }
+        position += 1;
+    }
+    throw new Error('Failed to scan JSON string.');
+};
+const scanJsonContainer = (text, start) => {
+    let depth = 0;
+    let position = start;
+    while (position < text.length) {
+        const character = text[position];
+        if (character === '"') {
+            position = scanJsonString(text, position);
+            continue;
+        }
+        if (character === '{' || character === '[') {
+            depth += 1;
+        }
+        if (character === '}' || character === ']') {
+            depth -= 1;
+            if (depth === 0) {
+                return position + 1;
+            }
+        }
+        position += 1;
+    }
+    throw new Error('Failed to scan JSON container.');
+};
+// Returns the position right after the value that starts at the given position.
+const scanJsonValue = (text, start) => {
+    const character = text[start];
+    if (character === '"') {
+        return scanJsonString(text, start);
+    }
+    if (character === '{' || character === '[') {
+        return scanJsonContainer(text, start);
+    }
+    let position = start;
+    while (position < text.length && !isJsonDelimiter(text[position])) {
+        position += 1;
+    }
+    return position;
+};
+export { scanJsonString, scanJsonValue, skipJsonWhitespace };

package/dist/ndjson/readNdJsonStream.d.ts

@@ -1,2 +1,8 @@
-declare const readNdJsonStream: (stream: ReadableStream<Uint8Array>, signal: AbortSignal, heartbeatTimeoutInMilliseconds?: number) => AsyncGenerator<Record<string, unknown>, void, void>;
+import type { StallGuard } from '../stall/StallGuard.js';
+interface NdJsonLine {
+    text: string;
+    value: Record<string, unknown>;
+}
+declare const readNdJsonStream: (stream: ReadableStream<Uint8Array>, signal: AbortSignal, stallGuard?: StallGuard) => AsyncGenerator<NdJsonLine, void, void>;
+export type { NdJsonLine };
 export { readNdJsonStream };

package/dist/ndjson/readNdJsonStream.js

@@ -1,27 +1,7 @@
-import { HeartbeatTimeoutError } from '../HeartbeatTimeoutError.js';
-const readNdJsonStream = async function* (stream, signal, heartbeatTimeoutInMilliseconds) {
+const readNdJsonStream = async function* (stream, signal, stallGuard) {
     const reader = stream.getReader();
     const decoder = new TextDecoder('utf-8');
     let buffer = '';
-    let heartbeatTimer;
-    let hasHeartbeatTimedOut = false;
-    // The timer only runs while waiting for the next line, not while the caller
-    // handles a line, so a slow caller does not cause a heartbeat timeout.
-    const startHeartbeatTimer = () => {
-        if (heartbeatTimeoutInMilliseconds === undefined || heartbeatTimer !== undefined) {
-            return;
-        }
-        heartbeatTimer = setTimeout(() => {
-            hasHeartbeatTimedOut = true;
-            reader.cancel().catch(() => {
-                // Intentionally left blank.
-            });
-        }, heartbeatTimeoutInMilliseconds);
-    };
-    const stopHeartbeatTimer = () => {
-        clearTimeout(heartbeatTimer);
-        heartbeatTimer = undefined;
-    };
     const onAbort = () => {
         reader.cancel().catch(() => {
             // Intentionally left blank.
@@ -36,7 +16,9 @@ const readNdJsonStream = async function* (stream, signal, heartbeatTimeoutInMill
     signal.addEventListener('abort', onAbort);
     try {
         while (!signal.aborted) {
-            startHeartbeatTimer();
+            // The clock only runs while waiting for the next chunk, not while the
+            // caller handles a line, so a slow caller does not cause a stall.
+            stallGuard?.restart();
             // biome-ignore lint/performance/noAwaitInLoops: Awaiting the result is fine here, although we are in a loop.
             const { done, value } = await reader.read();
             if (done) {
@@ -48,18 +30,15 @@ const readNdJsonStream = async function* (stream, signal, heartbeatTimeoutInMill
                 const line = buffer.slice(0, index).trim();
                 buffer = buffer.slice(index + 1);
                 if (line) {
-                    stopHeartbeatTimer();
-                    yield JSON.parse(line);
+                    stallGuard?.pause();
+                    yield { text: line, value: JSON.parse(line) };
                 }
                 index = buffer.indexOf('\n');
             }
         }
-        if (hasHeartbeatTimedOut) {
-            throw new HeartbeatTimeoutError();
-        }
     }
     finally {
-        stopHeartbeatTimer();
+        stallGuard?.pause();
         signal.removeEventListener('abort', onAbort);
         await reader.cancel().catch(() => {
             // Intentionally left blank.

package/dist/stall/StallGuard.d.ts

@@ -0,0 +1,14 @@
+declare class StallGuard {
+    #private;
+    constructor(stallTimeout: number, callerSignal?: AbortSignal);
+    get signal(): AbortSignal;
+    send(url: string, init: RequestInit): Promise<Response>;
+    onStall(createStallError: () => Error): void;
+    restart(): void;
+    pause(): void;
+    throwIfStalled(): void;
+    dispose({ abortRequest }: {
+        abortRequest: boolean;
+    }): void;
+}
+export { StallGuard };

package/dist/stall/StallGuard.js

@@ -0,0 +1,83 @@
+import { ConnectionStalledError } from '../ConnectionStalledError.js';
+import { createFetchTimeoutError } from './createFetchTimeoutError.js';
+// Ends a request once nothing arrives from the server for the stall timeout,
+// from sending the request until its end, including connecting and waiting
+// for the response headers. Everything that arrives restarts the clock, and
+// the clock stops while the caller handles an item of a stream. Aborting the
+// signal of the caller aborts the request as well.
+class StallGuard {
+    #stallTimeout;
+    #controller = new AbortController();
+    #callerSignal;
+    #createStallError;
+    #phase = 'headers';
+    #stallError;
+    #timer;
+    #onCallerAbort = () => {
+        this.#controller.abort(this.#callerSignal?.reason);
+    };
+    constructor(stallTimeout, callerSignal) {
+        this.#stallTimeout = stallTimeout;
+        this.#callerSignal = callerSignal;
+        this.#createStallError = () => new ConnectionStalledError(stallTimeout, {
+            cause: createFetchTimeoutError(this.#phase),
+        });
+        if (callerSignal?.aborted) {
+            this.#onCallerAbort();
+        }
+        else {
+            callerSignal?.addEventListener('abort', this.#onCallerAbort, { once: true });
+        }
+    }
+    // The signal of the request, which aborts once the request stalls or the
+    // caller aborts.
+    get signal() {
+        return this.#controller.signal;
+    }
+    // Sends the request with the signal of the guard. Once the headers of the
+    // response have arrived, the clock starts anew.
+    async send(url, init) {
+        const response = await fetch(url, { ...init, signal: this.#controller.signal });
+        this.#phase = 'body';
+        this.restart();
+        return response;
+    }
+    // From now on, a stall ends the request with the error that this creates.
+    onStall(createStallError) {
+        this.#createStallError = createStallError;
+    }
+    // Starts the clock, or starts it anew, since something arrived.
+    restart() {
+        if (this.#controller.signal.aborted) {
+            return;
+        }
+        // Starts a new timer rather than refreshing the running one, since the
+        // mocked timers of node:test do not move a refreshed timer.
+        this.pause();
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            this.#stallError = this.#createStallError();
+            this.#controller.abort(this.#stallError);
+        }, this.#stallTimeout);
+    }
+    // Stops the clock, while the caller handles an item of a stream.
+    pause() {
+        clearTimeout(this.#timer);
+        this.#timer = undefined;
+    }
+    throwIfStalled() {
+        if (this.#stallError !== undefined) {
+            throw this.#stallError;
+        }
+    }
+    // Stops watching the request. Aborting it as well closes its connection,
+    // which a stream needs, since it may end before its body does.
+    dispose({ abortRequest }) {
+        this.pause();
+        this.#callerSignal?.removeEventListener('abort', this.#onCallerAbort);
+        if (abortRequest) {
+            this.#controller.abort();
+        }
+    }
+}
+export { StallGuard };

package/dist/stall/createFetchTimeoutError.d.ts

@@ -0,0 +1,2 @@
+declare const createFetchTimeoutError: (phase: 'headers' | 'body') => Error;
+export { createFetchTimeoutError };

package/dist/stall/createFetchTimeoutError.js

@@ -0,0 +1,16 @@
+// Creates an error like the one that the fetch built into Node.js gives as
+// the cause of its TypeError when it times out, with the same name, code, and
+// message, so that code that checks the code of the cause keeps working.
+const createFetchTimeoutError = (phase) => {
+    if (phase === 'headers') {
+        return Object.assign(new Error('Headers Timeout Error'), {
+            name: 'HeadersTimeoutError',
+            code: 'UND_ERR_HEADERS_TIMEOUT',
+        });
+    }
+    return Object.assign(new Error('Body Timeout Error'), {
+        name: 'BodyTimeoutError',
+        code: 'UND_ERR_BODY_TIMEOUT',
+    });
+};
+export { createFetchTimeoutError };

package/dist/stall/defaultStallTimeout.d.ts

@@ -0,0 +1,3 @@
+declare const defaultStallTimeout = 30000;
+declare const maximumStallTimeout = 2147483647;
+export { defaultStallTimeout, maximumStallTimeout };

package/dist/stall/defaultStallTimeout.js

@@ -0,0 +1,6 @@
+// A request fails once nothing arrives from the server for this many
+// milliseconds, unless the client is configured otherwise.
+const defaultStallTimeout = 30_000;
+// Node.js runs a timer for at most this many milliseconds.
+const maximumStallTimeout = 2_147_483_647;
+export { defaultStallTimeout, maximumStallTimeout };

package/dist/stall/formatDuration.d.ts

@@ -0,0 +1,2 @@
+declare const formatDuration: (milliseconds: number) => string;
+export { formatDuration };

package/dist/stall/formatDuration.js

@@ -0,0 +1,9 @@
+const millisecondsPerSecond = 1000;
+const formatDuration = (milliseconds) => {
+    if (milliseconds % millisecondsPerSecond === 0) {
+        const seconds = milliseconds / millisecondsPerSecond;
+        return `${seconds} ${seconds === 1 ? 'second' : 'seconds'}`;
+    }
+    return `${milliseconds} ${milliseconds === 1 ? 'millisecond' : 'milliseconds'}`;
+};
+export { formatDuration };

package/dist/stall/readResponseText.d.ts

@@ -0,0 +1,3 @@
+import type { StallGuard } from './StallGuard.js';
+declare const readResponseText: (response: Response, stallGuard: StallGuard) => Promise<string>;
+export { readResponseText };

package/dist/stall/readResponseText.js

@@ -0,0 +1,26 @@
+// Reads the body of a response as text, like response.text(), but restarts
+// the clock of the stall guard with every chunk that arrives.
+const readResponseText = async (response, stallGuard) => {
+    if (!response.body) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let text = '';
+    try {
+        stallGuard.restart();
+        let result = await reader.read();
+        while (!result.done) {
+            text += decoder.decode(result.value, { stream: true });
+            stallGuard.restart();
+            // biome-ignore lint/performance/noAwaitInLoops: Awaiting the result is fine here, although we are in a loop.
+            result = await reader.read();
+        }
+        text += decoder.decode();
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return text;
+};
+export { readResponseText };

package/dist/stall/runWithStallGuard.d.ts

@@ -0,0 +1,6 @@
+import { StallGuard } from './StallGuard.js';
+declare const runWithStallGuard: <TResult>({ stallTimeout, signal }: {
+    stallTimeout: number;
+    signal?: AbortSignal;
+}, run: (stallGuard: StallGuard) => Promise<TResult>) => Promise<TResult>;
+export { runWithStallGuard };