@prisma/composer-prisma-cloud 0.1.0-dev.18 → 0.1.0-dev.3

package/dist/streams/index.mjs

@@ -1,6 +1,6 @@
 import { dependency, hydrateSecrets, hydrateSync, module, number, provisionNeed, resource, service, string } from "@prisma/composer";
 import { blindCast } from "@prisma/composer/casts";
-import { RPC_PEER_KEY } from "@prisma/composer/service-rpc";
+import { RPC_PEER_KEY } from "@prisma/composer/rpc";
 import { type } from "arktype";
 import node from "@prisma/composer/node";
 blindCast(Symbol.for("prisma:prisma-cloud-secret-source"));
@@ -199,7 +199,7 @@ function standardValidateSync(schema, value) {
 	return result.value;
 }
 //#endregion
-//#region ../../1-prisma-cloud/1-extensions/target/dist/provisioned-edges-DIQAR4q4.mjs
+//#region ../../1-prisma-cloud/1-extensions/target/dist/provisioned-edges-Bb7WiV49.mjs
 /**
 * RPC's reserved provider param (ADR-0030/ADR-0031): the declaration —
 * name + schema + brand — for the accepted-keys set a provider stores, shared
@@ -218,7 +218,7 @@ function standardValidateSync(schema, value) {
 * The reserved provider param for RPC's accepted-keys set: the var name is
 * `RPC_ACCEPTED_KEYS`, derived through `configKey` at both ends
 * (`configKey(address, …)` at deploy, `configKey('', …)` at boot — the
-* address-free form is `@internal/service-rpc`'s `RPC_ACCEPTED_KEYS_ENV`). `brand` is
+* address-free form is `@internal/rpc`'s `RPC_ACCEPTED_KEYS_ENV`). `brand` is
 * `RPC_PEER_KEY`, the same brand `perBindingToken()`'s need carries — control.ts
 * looks its `value(refs)` up by this field.
 */
@@ -254,16 +254,8 @@ configKey("", {
 });
 const RESERVED_PROVIDER_PARAMS = [RPC_ACCEPTED_KEYS_PARAM, STREAMS_API_KEY_PARAM];
 blindCast(Symbol.for("prisma:prisma-cloud-param-source"));
-Object.freeze({
-	kind: "s3",
-	__cmp: {
-		url: "",
-		bucket: "",
-		accessKeyId: "",
-		secretAccessKey: ""
-	},
-	satisfies: (required) => required.kind === "s3"
-});
+//#endregion
+//#region ../../1-prisma-cloud/1-extensions/target/dist/index.mjs
 const reservedParams = { port: number({ default: 3e3 }) };
 /**
 * A Prisma Compute service — declarations only (deps + params + build + the
@@ -416,7 +408,7 @@ function s3StoreService(def) {
 	}));
 }
 //#endregion
-//#region ../../1-prisma-cloud/2-shared-modules/storage/dist/storage-service-DSaZsAC4.mjs
+//#region ../../1-prisma-cloud/2-shared-modules/storage/dist/storage-service-BQdOiMsW.mjs
 const s3Contract = Object.freeze({
 	kind: "s3",
 	__cmp: {
@@ -473,7 +465,7 @@ function storageService(opts) {
 }
 storageService({ bucket: "storage" });
 //#endregion
-//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/streams-service-Cg8rwrZa.mjs
+//#region ../../1-prisma-cloud/2-shared-modules/streams/dist/streams-service-Mz48Yi0V.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -872,7 +864,7 @@ var FetchError = class FetchError extends Error {
 		let text = void 0;
 		let json = void 0;
 		const contentType = response.headers.get(`content-type`);
-		if (!response.bodyUsed && response.body !== null) if (contentType && contentType.includes(`application/json`)) try {
+		if (!response.bodyUsed) if (contentType && contentType.includes(`application/json`)) try {
 			json = await response.json();
 		} catch {
 			text = await response.text();
@@ -921,7 +913,7 @@ var DurableStreamError = class DurableStreamError extends Error {
 		const status = response.status;
 		let details;
 		const contentType = response.headers.get(`content-type`);
-		if (!response.bodyUsed && response.body !== null) if (contentType && contentType.includes(`application/json`)) try {
+		if (!response.bodyUsed) if (contentType && contentType.includes(`application/json`)) try {
 			details = await response.json();
 		} catch {
 			details = await response.text();
@@ -1290,204 +1282,6 @@ async function* parseSSEStream(stream$1, signal) {
 	}
 }
 /**
-* Abstract base class for stream response state.
-* All state transitions return new immutable state objects.
-*/
-var StreamResponseState = class {
-	shouldContinueLive(stopAfterUpToDate, liveMode) {
-		if (stopAfterUpToDate && this.upToDate) return false;
-		if (liveMode === false) return false;
-		if (this.streamClosed) return false;
-		return true;
-	}
-};
-/**
-* State for long-poll mode. shouldUseSse() returns false.
-*/
-var LongPollState = class LongPollState extends StreamResponseState {
-	offset;
-	cursor;
-	upToDate;
-	streamClosed;
-	constructor(fields) {
-		super();
-		this.offset = fields.offset;
-		this.cursor = fields.cursor;
-		this.upToDate = fields.upToDate;
-		this.streamClosed = fields.streamClosed;
-	}
-	shouldUseSse() {
-		return false;
-	}
-	withResponseMetadata(update) {
-		return new LongPollState({
-			offset: update.offset ?? this.offset,
-			cursor: update.cursor ?? this.cursor,
-			upToDate: update.upToDate,
-			streamClosed: this.streamClosed || update.streamClosed
-		});
-	}
-	withSSEControl(event) {
-		const streamClosed = this.streamClosed || (event.streamClosed ?? false);
-		return new LongPollState({
-			offset: event.streamNextOffset,
-			cursor: event.streamCursor || this.cursor,
-			upToDate: event.streamClosed ?? false ? true : event.upToDate ?? this.upToDate,
-			streamClosed
-		});
-	}
-	pause() {
-		return new PausedState(this);
-	}
-};
-/**
-* State for SSE mode. shouldUseSse() returns true.
-* Tracks SSE connection resilience (short connection detection).
-*/
-var SSEState = class SSEState extends StreamResponseState {
-	offset;
-	cursor;
-	upToDate;
-	streamClosed;
-	consecutiveShortConnections;
-	connectionStartTime;
-	constructor(fields) {
-		super();
-		this.offset = fields.offset;
-		this.cursor = fields.cursor;
-		this.upToDate = fields.upToDate;
-		this.streamClosed = fields.streamClosed;
-		this.consecutiveShortConnections = fields.consecutiveShortConnections ?? 0;
-		this.connectionStartTime = fields.connectionStartTime;
-	}
-	shouldUseSse() {
-		return true;
-	}
-	withResponseMetadata(update) {
-		return new SSEState({
-			offset: update.offset ?? this.offset,
-			cursor: update.cursor ?? this.cursor,
-			upToDate: update.upToDate,
-			streamClosed: this.streamClosed || update.streamClosed,
-			consecutiveShortConnections: this.consecutiveShortConnections,
-			connectionStartTime: this.connectionStartTime
-		});
-	}
-	withSSEControl(event) {
-		const streamClosed = this.streamClosed || (event.streamClosed ?? false);
-		return new SSEState({
-			offset: event.streamNextOffset,
-			cursor: event.streamCursor || this.cursor,
-			upToDate: event.streamClosed ?? false ? true : event.upToDate ?? this.upToDate,
-			streamClosed,
-			consecutiveShortConnections: this.consecutiveShortConnections,
-			connectionStartTime: this.connectionStartTime
-		});
-	}
-	startConnection(now) {
-		return new SSEState({
-			offset: this.offset,
-			cursor: this.cursor,
-			upToDate: this.upToDate,
-			streamClosed: this.streamClosed,
-			consecutiveShortConnections: this.consecutiveShortConnections,
-			connectionStartTime: now
-		});
-	}
-	handleConnectionEnd(now, wasAborted, config) {
-		if (this.connectionStartTime === void 0) return {
-			action: `healthy`,
-			state: this
-		};
-		const duration = now - this.connectionStartTime;
-		if (duration < config.minConnectionDuration && !wasAborted) {
-			const newCount = this.consecutiveShortConnections + 1;
-			if (newCount >= config.maxShortConnections) return {
-				action: `fallback`,
-				state: new LongPollState({
-					offset: this.offset,
-					cursor: this.cursor,
-					upToDate: this.upToDate,
-					streamClosed: this.streamClosed
-				})
-			};
-			return {
-				action: `reconnect`,
-				state: new SSEState({
-					offset: this.offset,
-					cursor: this.cursor,
-					upToDate: this.upToDate,
-					streamClosed: this.streamClosed,
-					consecutiveShortConnections: newCount,
-					connectionStartTime: this.connectionStartTime
-				}),
-				backoffAttempt: newCount
-			};
-		}
-		if (duration >= config.minConnectionDuration) return {
-			action: `healthy`,
-			state: new SSEState({
-				offset: this.offset,
-				cursor: this.cursor,
-				upToDate: this.upToDate,
-				streamClosed: this.streamClosed,
-				consecutiveShortConnections: 0,
-				connectionStartTime: this.connectionStartTime
-			})
-		};
-		return {
-			action: `healthy`,
-			state: this
-		};
-	}
-	pause() {
-		return new PausedState(this);
-	}
-};
-/**
-* Paused state wrapper. Delegates all sync field access to the inner state.
-* resume() returns the wrapped state unchanged (identity preserved).
-*/
-var PausedState = class PausedState extends StreamResponseState {
-	#inner;
-	constructor(inner) {
-		super();
-		this.#inner = inner;
-	}
-	get offset() {
-		return this.#inner.offset;
-	}
-	get cursor() {
-		return this.#inner.cursor;
-	}
-	get upToDate() {
-		return this.#inner.upToDate;
-	}
-	get streamClosed() {
-		return this.#inner.streamClosed;
-	}
-	shouldUseSse() {
-		return this.#inner.shouldUseSse();
-	}
-	withResponseMetadata(update) {
-		const newInner = this.#inner.withResponseMetadata(update);
-		return new PausedState(newInner);
-	}
-	withSSEControl(event) {
-		const newInner = this.#inner.withSSEControl(event);
-		return new PausedState(newInner);
-	}
-	pause() {
-		return this;
-	}
-	resume() {
-		return {
-			state: this.#inner,
-			justResumed: true
-		};
-	}
-};
-/**
 * Constant used as abort reason when pausing the stream due to visibility change.
 */
 const PAUSE_STREAM = `PAUSE_STREAM`;
@@ -1504,7 +1298,10 @@ var StreamResponseImpl = class {
 	#statusText;
 	#ok;
 	#isLoading;
-	#syncState;
+	#offset;
+	#cursor;
+	#upToDate;
+	#streamClosed;
 	#isJsonMode;
 	#abortController;
 	#fetchNext;
@@ -1519,7 +1316,11 @@ var StreamResponseImpl = class {
 	#unsubscribeFromVisibilityChanges;
 	#pausePromise;
 	#pauseResolve;
+	#justResumedFromPause = false;
 	#sseResilience;
+	#lastSSEConnectionStartTime;
+	#consecutiveShortSSEConnections = 0;
+	#sseFallbackToLongPoll = false;
 	#encoding;
 	#responseStream;
 	constructor(config) {
@@ -1527,13 +1328,10 @@ var StreamResponseImpl = class {
 		this.contentType = config.contentType;
 		this.live = config.live;
 		this.startOffset = config.startOffset;
-		const syncFields = {
-			offset: config.initialOffset,
-			cursor: config.initialCursor,
-			upToDate: config.initialUpToDate,
-			streamClosed: config.initialStreamClosed
-		};
-		this.#syncState = config.startSSE ? new SSEState(syncFields) : new LongPollState(syncFields);
+		this.#offset = config.initialOffset;
+		this.#cursor = config.initialCursor;
+		this.#upToDate = config.initialUpToDate;
+		this.#streamClosed = config.initialStreamClosed;
 		this.#headers = config.firstResponse.headers;
 		this.#status = config.firstResponse.status;
 		this.#statusText = config.firstResponse.statusText;
@@ -1590,7 +1388,6 @@ var StreamResponseImpl = class {
 	#pause() {
 		if (this.#state === `active`) {
 			this.#state = `pause-requested`;
-			this.#syncState = this.#syncState.pause();
 			this.#pausePromise = new Promise((resolve) => {
 				this.#pauseResolve = resolve;
 			});
@@ -1604,8 +1401,8 @@ var StreamResponseImpl = class {
 	#resume() {
 		if (this.#state === `paused` || this.#state === `pause-requested`) {
 			if (this.#abortController.signal.aborted) return;
-			if (this.#syncState instanceof PausedState) this.#syncState = this.#syncState.resume().state;
 			this.#state = `active`;
+			this.#justResumedFromPause = true;
 			this.#pauseResolve?.();
 			this.#pausePromise = void 0;
 			this.#pauseResolve = void 0;
@@ -1627,16 +1424,16 @@ var StreamResponseImpl = class {
 		return this.#isLoading;
 	}
 	get offset() {
-		return this.#syncState.offset;
+		return this.#offset;
 	}
 	get cursor() {
-		return this.#syncState.cursor;
+		return this.#cursor;
 	}
 	get upToDate() {
-		return this.#syncState.upToDate;
+		return this.#upToDate;
 	}
 	get streamClosed() {
-		return this.#syncState.streamClosed;
+		return this.#streamClosed;
 	}
 	#ensureJsonMode() {
 		if (!this.#isJsonMode) throw new DurableStreamError(`JSON methods are only valid for JSON-mode streams. Content-Type is "${this.contentType}" and json hint was not set.`, `BAD_REQUEST`);
@@ -1662,68 +1459,160 @@ var StreamResponseImpl = class {
 	* and whether we've received upToDate or streamClosed.
 	*/
 	#shouldContinueLive() {
-		return this.#syncState.shouldContinueLive(this.#stopAfterUpToDate, this.live);
+		if (this.#stopAfterUpToDate && this.upToDate) return false;
+		if (this.live === false) return false;
+		if (this.#streamClosed) return false;
+		return true;
 	}
 	/**
 	* Update state from response headers.
 	*/
 	#updateStateFromResponse(response) {
-		this.#syncState = this.#syncState.withResponseMetadata({
-			offset: response.headers.get(STREAM_OFFSET_HEADER) || void 0,
-			cursor: response.headers.get(STREAM_CURSOR_HEADER) || void 0,
-			upToDate: response.headers.has(STREAM_UP_TO_DATE_HEADER),
-			streamClosed: response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`
-		});
+		const offset = response.headers.get(STREAM_OFFSET_HEADER);
+		if (offset) this.#offset = offset;
+		const cursor = response.headers.get(STREAM_CURSOR_HEADER);
+		if (cursor) this.#cursor = cursor;
+		this.#upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER);
+		if (response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`) this.#streamClosed = true;
 		this.#headers = response.headers;
 		this.#status = response.status;
 		this.#statusText = response.statusText;
 		this.#ok = response.ok;
 	}
 	/**
+	* Extract stream metadata from Response headers.
+	* Used by subscriber APIs to get the correct offset/cursor/upToDate/streamClosed for each
+	* specific Response, rather than reading from `this` which may be stale due to
+	* ReadableStream prefetching or timing issues.
+	*/
+	#getMetadataFromResponse(response) {
+		const offset = response.headers.get(STREAM_OFFSET_HEADER);
+		const cursor = response.headers.get(STREAM_CURSOR_HEADER);
+		const upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER);
+		const streamClosed = response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
+		return {
+			offset: offset ?? this.offset,
+			cursor: cursor ?? this.cursor,
+			upToDate,
+			streamClosed: streamClosed || this.streamClosed
+		};
+	}
+	/**
+	* Decode base64 string to Uint8Array.
+	* Per protocol: concatenate data lines, remove \n and \r, then decode.
+	*/
+	#decodeBase64(base64Str) {
+		const cleaned = base64Str.replace(/[\n\r]/g, ``);
+		if (cleaned.length === 0) return /* @__PURE__ */ new Uint8Array(0);
+		if (cleaned.length % 4 !== 0) throw new DurableStreamError(`Invalid base64 data: length ${cleaned.length} is not a multiple of 4`, `PARSE_ERROR`);
+		try {
+			if (typeof Buffer !== `undefined`) return new Uint8Array(Buffer.from(cleaned, `base64`));
+			else {
+				const binaryStr = atob(cleaned);
+				const bytes = new Uint8Array(binaryStr.length);
+				for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
+				return bytes;
+			}
+		} catch (err) {
+			throw new DurableStreamError(`Failed to decode base64 data: ${err instanceof Error ? err.message : String(err)}`, `PARSE_ERROR`);
+		}
+	}
+	/**
+	* Create a synthetic Response from SSE data with proper headers.
+	* Includes offset/cursor/upToDate/streamClosed in headers so subscribers can read them.
+	*/
+	#createSSESyntheticResponse(data, offset, cursor, upToDate, streamClosed) {
+		return this.#createSSESyntheticResponseFromParts([data], offset, cursor, upToDate, streamClosed);
+	}
+	/**
+	* Create a synthetic Response from multiple SSE data parts.
+	* For base64 mode, each part is independently encoded, so we decode each
+	* separately and concatenate the binary results.
+	* For text mode, parts are simply concatenated as strings.
+	*/
+	#createSSESyntheticResponseFromParts(dataParts, offset, cursor, upToDate, streamClosed) {
+		const headers = {
+			"content-type": this.contentType ?? `application/json`,
+			[STREAM_OFFSET_HEADER]: String(offset)
+		};
+		if (cursor) headers[STREAM_CURSOR_HEADER] = cursor;
+		if (upToDate) headers[STREAM_UP_TO_DATE_HEADER] = `true`;
+		if (streamClosed) headers[STREAM_CLOSED_HEADER] = `true`;
+		let body;
+		if (this.#encoding === `base64`) {
+			const decodedParts = dataParts.filter((part) => part.length > 0).map((part) => this.#decodeBase64(part));
+			if (decodedParts.length === 0) body = /* @__PURE__ */ new ArrayBuffer(0);
+			else if (decodedParts.length === 1) {
+				const decoded = decodedParts[0];
+				body = decoded.buffer.slice(decoded.byteOffset, decoded.byteOffset + decoded.byteLength);
+			} else {
+				const totalLength = decodedParts.reduce((sum, part) => sum + part.length, 0);
+				const combined = new Uint8Array(totalLength);
+				let offset$1 = 0;
+				for (const part of decodedParts) {
+					combined.set(part, offset$1);
+					offset$1 += part.length;
+				}
+				body = combined.buffer;
+			}
+		} else body = dataParts.join(``);
+		return new Response(body, {
+			status: 200,
+			headers
+		});
+	}
+	/**
 	* Update instance state from an SSE control event.
 	*/
 	#updateStateFromSSEControl(controlEvent) {
-		this.#syncState = this.#syncState.withSSEControl(controlEvent);
-	}
-	#updateEncodingFromSSEResponse(response) {
-		this.#encoding = response.headers.get(STREAM_SSE_DATA_ENCODING_HEADER) === `base64` ? `base64` : void 0;
+		this.#offset = controlEvent.streamNextOffset;
+		if (controlEvent.streamCursor) this.#cursor = controlEvent.streamCursor;
+		if (controlEvent.upToDate !== void 0) this.#upToDate = controlEvent.upToDate;
+		if (controlEvent.streamClosed) {
+			this.#streamClosed = true;
+			this.#upToDate = true;
+		}
 	}
 	/**
 	* Mark the start of an SSE connection for duration tracking.
-	* If the state is not SSEState (e.g., auto-detected SSE from content-type),
-	* transitions to SSEState first.
 	*/
 	#markSSEConnectionStart() {
-		if (!(this.#syncState instanceof SSEState)) this.#syncState = new SSEState({
-			offset: this.#syncState.offset,
-			cursor: this.#syncState.cursor,
-			upToDate: this.#syncState.upToDate,
-			streamClosed: this.#syncState.streamClosed
-		});
-		this.#syncState = this.#syncState.startConnection(Date.now());
+		this.#lastSSEConnectionStartTime = Date.now();
+	}
+	/**
+	* Handle SSE connection end - check duration and manage fallback state.
+	* Returns a delay to wait before reconnecting, or null if should not reconnect.
+	*/
+	async #handleSSEConnectionEnd() {
+		if (this.#lastSSEConnectionStartTime === void 0) return 0;
+		const connectionDuration = Date.now() - this.#lastSSEConnectionStartTime;
+		const wasAborted = this.#abortController.signal.aborted;
+		if (connectionDuration < this.#sseResilience.minConnectionDuration && !wasAborted) {
+			this.#consecutiveShortSSEConnections++;
+			if (this.#consecutiveShortSSEConnections >= this.#sseResilience.maxShortConnections) {
+				this.#sseFallbackToLongPoll = true;
+				if (this.#sseResilience.logWarnings) console.warn("[Durable Streams] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). Falling back to long polling. Your proxy must support streaming SSE responses (not buffer the complete response). Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy.");
+				return null;
+			} else {
+				const maxDelay = Math.min(this.#sseResilience.backoffMaxDelay, this.#sseResilience.backoffBaseDelay * Math.pow(2, this.#consecutiveShortSSEConnections));
+				const delayMs = Math.floor(Math.random() * maxDelay);
+				await new Promise((resolve) => setTimeout(resolve, delayMs));
+				return delayMs;
+			}
+		} else if (connectionDuration >= this.#sseResilience.minConnectionDuration) this.#consecutiveShortSSEConnections = 0;
+		return 0;
 	}
 	/**
 	* Try to reconnect SSE and return the new iterator, or null if reconnection
 	* is not possible or fails.
 	*/
 	async #trySSEReconnect() {
-		if (!this.#syncState.shouldUseSse()) return null;
+		if (this.#sseFallbackToLongPoll) return null;
 		if (!this.#shouldContinueLive() || !this.#startSSE) return null;
-		const result = this.#syncState.handleConnectionEnd(Date.now(), this.#abortController.signal.aborted, this.#sseResilience);
-		this.#syncState = result.state;
-		if (result.action === `fallback`) {
-			if (this.#sseResilience.logWarnings) console.warn("[Durable Streams] SSE connections are closing immediately (possibly due to proxy buffering or misconfiguration). Falling back to long polling. Your proxy must support streaming SSE responses (not buffer the complete response). Configuration: Nginx add 'X-Accel-Buffering: no', Caddy add 'flush_interval -1' to reverse_proxy.");
-			return null;
-		}
-		if (result.action === `reconnect`) {
-			const maxDelay = Math.min(this.#sseResilience.backoffMaxDelay, this.#sseResilience.backoffBaseDelay * Math.pow(2, result.backoffAttempt));
-			const delayMs = Math.floor(Math.random() * maxDelay);
-			await new Promise((resolve) => setTimeout(resolve, delayMs));
-		}
+		if (await this.#handleSSEConnectionEnd() === null) return null;
 		this.#markSSEConnectionStart();
 		this.#requestAbortController = new AbortController();
 		const newSSEResponse = await this.#startSSE(this.offset, this.cursor, this.#requestAbortController.signal);
-		this.#updateEncodingFromSSEResponse(newSSEResponse);
 		if (newSSEResponse.body) return parseSSEStream(newSSEResponse.body, this.#requestAbortController.signal);
 		return null;
 	}
@@ -1756,7 +1645,7 @@ var StreamResponseImpl = class {
 		this.#updateStateFromSSEControl(event);
 		if (event.upToDate) return {
 			type: `response`,
-			response: createSSESyntheticResponse(``, event.streamNextOffset, event.streamCursor, true, event.streamClosed ?? false, this.contentType, this.#encoding)
+			response: this.#createSSESyntheticResponse(``, event.streamNextOffset, event.streamCursor, true, event.streamClosed ?? false)
 		};
 		return { type: `continue` };
 	}
@@ -1773,7 +1662,7 @@ var StreamResponseImpl = class {
 		while (true) {
 			const { done: controlDone, value: controlEvent } = await sseEventIterator.next();
 			if (controlDone) {
-				const response = createSSESyntheticResponseFromParts(bufferedDataParts, this.offset, this.cursor, this.upToDate, this.streamClosed, this.contentType, this.#encoding, this.#isJsonMode);
+				const response = this.#createSSESyntheticResponseFromParts(bufferedDataParts, this.offset, this.cursor, this.upToDate, this.streamClosed);
 				try {
 					return {
 						type: `response`,
@@ -1791,7 +1680,7 @@ var StreamResponseImpl = class {
 				this.#updateStateFromSSEControl(controlEvent);
 				return {
 					type: `response`,
-					response: createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false, this.contentType, this.#encoding, this.#isJsonMode)
+					response: this.#createSSESyntheticResponseFromParts(bufferedDataParts, controlEvent.streamNextOffset, controlEvent.streamCursor, controlEvent.upToDate ?? false, controlEvent.streamClosed ?? false)
 				};
 			}
 			bufferedDataParts.push(controlEvent.data);
@@ -1814,7 +1703,6 @@ var StreamResponseImpl = class {
 						firstResponseYielded = true;
 						if ((firstResponse.headers.get(`content-type`)?.includes(`text/event-stream`) ?? false) && firstResponse.body) {
 							this.#markSSEConnectionStart();
-							this.#updateEncodingFromSSEResponse(firstResponse);
 							this.#requestAbortController = new AbortController();
 							sseEventIterator = parseSSEStream(firstResponse.body, this.#requestAbortController.signal);
 						} else {
@@ -1827,22 +1715,6 @@ var StreamResponseImpl = class {
 							return;
 						}
 					}
-					if (!sseEventIterator && this.upToDate && this.#startSSE && this.#shouldContinueLive()) {
-						if (this.#state === `pause-requested` || this.#state === `paused`) {
-							this.#state = `paused`;
-							if (this.#pausePromise) await this.#pausePromise;
-							if (this.#abortController.signal.aborted) {
-								this.#markClosed();
-								controller.close();
-								return;
-							}
-						}
-						this.#markSSEConnectionStart();
-						this.#requestAbortController = new AbortController();
-						const sseResponse = await this.#startSSE(this.offset, this.cursor, this.#requestAbortController.signal);
-						this.#updateEncodingFromSSEResponse(sseResponse);
-						if (sseResponse.body) sseEventIterator = parseSSEStream(sseResponse.body, this.#requestAbortController.signal);
-					}
 					if (sseEventIterator) {
 						if (this.#state === `pause-requested` || this.#state === `paused`) {
 							this.#state = `paused`;
@@ -1882,7 +1754,6 @@ var StreamResponseImpl = class {
 						}
 					}
 					if (this.#shouldContinueLive()) {
-						let resumingFromPause = false;
 						if (this.#state === `pause-requested` || this.#state === `paused`) {
 							this.#state = `paused`;
 							if (this.#pausePromise) await this.#pausePromise;
@@ -1891,15 +1762,16 @@ var StreamResponseImpl = class {
 								controller.close();
 								return;
 							}
-							resumingFromPause = true;
 						}
 						if (this.#abortController.signal.aborted) {
 							this.#markClosed();
 							controller.close();
 							return;
 						}
+						const resumingFromPause = this.#justResumedFromPause;
+						this.#justResumedFromPause = false;
 						this.#requestAbortController = new AbortController();
-						const response = await this.#fetchNext(this.offset, this.cursor, this.#requestAbortController.signal, this.upToDate, resumingFromPause);
+						const response = await this.#fetchNext(this.offset, this.cursor, this.#requestAbortController.signal, resumingFromPause);
 						this.#updateStateFromResponse(response);
 						controller.enqueue(response);
 						return;
@@ -2062,25 +1934,22 @@ var StreamResponseImpl = class {
 					controller.enqueue(pendingItems.shift());
 					return;
 				}
-				let result = await reader.read();
-				while (!result.done) {
-					const content = (await result.value.text()).trim() || `[]`;
-					let parsed;
-					try {
-						parsed = JSON.parse(content);
-					} catch (err) {
-						const preview = content.length > 100 ? content.slice(0, 100) + `...` : content;
-						throw new DurableStreamError(`Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`, `PARSE_ERROR`);
-					}
-					pendingItems = Array.isArray(parsed) ? parsed : [parsed];
-					if (pendingItems.length > 0) {
-						controller.enqueue(pendingItems.shift());
-						return;
-					}
-					result = await reader.read();
+				const { done, value: response } = await reader.read();
+				if (done) {
+					this.#markClosed();
+					controller.close();
+					return;
 				}
-				this.#markClosed();
-				controller.close();
+				const content = (await response.text()).trim() || `[]`;
+				let parsed;
+				try {
+					parsed = JSON.parse(content);
+				} catch (err) {
+					const preview = content.length > 100 ? content.slice(0, 100) + `...` : content;
+					throw new DurableStreamError(`Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}. Data: ${preview}`, `PARSE_ERROR`);
+				}
+				pendingItems = Array.isArray(parsed) ? parsed : [parsed];
+				if (pendingItems.length > 0) controller.enqueue(pendingItems.shift());
 			},
 			cancel: () => {
 				reader.releaseLock();
@@ -2112,7 +1981,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate, streamClosed } = getMetadataFromResponse(response, this.offset, this.cursor, this.streamClosed);
+					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
 					const content = (await response.text()).trim() || `[]`;
 					let parsed;
 					try {
@@ -2156,7 +2025,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate, streamClosed } = getMetadataFromResponse(response, this.offset, this.cursor, this.streamClosed);
+					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
 					const buffer = await response.arrayBuffer();
 					await subscriber({
 						data: new Uint8Array(buffer),
@@ -2193,7 +2062,7 @@ var StreamResponseImpl = class {
 				while (!result.done) {
 					if (abortController.signal.aborted) break;
 					const response = result.value;
-					const { offset, cursor, upToDate, streamClosed } = getMetadataFromResponse(response, this.offset, this.cursor, this.streamClosed);
+					const { offset, cursor, upToDate, streamClosed } = this.#getMetadataFromResponse(response);
 					await subscriber({
 						text: await response.text(),
 						offset,
@@ -2229,97 +2098,6 @@ var StreamResponseImpl = class {
 	}
 };
 /**
-* Extract stream metadata from Response headers.
-* Falls back to the provided defaults when headers are absent.
-*/
-function getMetadataFromResponse(response, fallbackOffset, fallbackCursor, fallbackStreamClosed) {
-	const offset = response.headers.get(STREAM_OFFSET_HEADER);
-	const cursor = response.headers.get(STREAM_CURSOR_HEADER);
-	const upToDate = response.headers.has(STREAM_UP_TO_DATE_HEADER);
-	const streamClosed = response.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
-	return {
-		offset: offset ?? fallbackOffset,
-		cursor: cursor ?? fallbackCursor,
-		upToDate,
-		streamClosed: streamClosed || fallbackStreamClosed
-	};
-}
-/**
-* Decode base64 string to Uint8Array.
-* Per protocol: concatenate data lines, remove \n and \r, then decode.
-*/
-function decodeBase64(base64Str) {
-	const cleaned = base64Str.replace(/[\n\r]/g, ``);
-	if (cleaned.length === 0) return /* @__PURE__ */ new Uint8Array(0);
-	if (cleaned.length % 4 !== 0) throw new DurableStreamError(`Invalid base64 data: length ${cleaned.length} is not a multiple of 4`, `PARSE_ERROR`);
-	try {
-		if (typeof Buffer !== `undefined`) return new Uint8Array(Buffer.from(cleaned, `base64`));
-		else {
-			const binaryStr = atob(cleaned);
-			const bytes = new Uint8Array(binaryStr.length);
-			for (let i = 0; i < binaryStr.length; i++) bytes[i] = binaryStr.charCodeAt(i);
-			return bytes;
-		}
-	} catch (err) {
-		throw new DurableStreamError(`Failed to decode base64 data: ${err instanceof Error ? err.message : String(err)}`, `PARSE_ERROR`);
-	}
-}
-/**
-* Create a synthetic Response from SSE data with proper headers.
-* Includes offset/cursor/upToDate/streamClosed in headers so subscribers can read them.
-*/
-function createSSESyntheticResponse(data, offset, cursor, upToDate, streamClosed, contentType, encoding) {
-	return createSSESyntheticResponseFromParts([data], offset, cursor, upToDate, streamClosed, contentType, encoding);
-}
-/**
-* Create a synthetic Response from multiple SSE data parts.
-* For base64 mode, each part is independently encoded, so we decode each
-* separately and concatenate the binary results.
-* For text mode, parts are simply concatenated as strings.
-*/
-function createSSESyntheticResponseFromParts(dataParts, offset, cursor, upToDate, streamClosed, contentType, encoding, isJsonMode) {
-	const headers = {
-		"content-type": contentType ?? `application/json`,
-		[STREAM_OFFSET_HEADER]: String(offset)
-	};
-	if (cursor) headers[STREAM_CURSOR_HEADER] = cursor;
-	if (upToDate) headers[STREAM_UP_TO_DATE_HEADER] = `true`;
-	if (streamClosed) headers[STREAM_CLOSED_HEADER] = `true`;
-	let body;
-	if (encoding === `base64`) {
-		const decodedParts = dataParts.filter((part) => part.length > 0).map((part) => decodeBase64(part));
-		if (decodedParts.length === 0) body = /* @__PURE__ */ new ArrayBuffer(0);
-		else if (decodedParts.length === 1) {
-			const decoded = decodedParts[0];
-			body = decoded.buffer.slice(decoded.byteOffset, decoded.byteOffset + decoded.byteLength);
-		} else {
-			const totalLength = decodedParts.reduce((sum, part) => sum + part.length, 0);
-			const combined = new Uint8Array(totalLength);
-			let offset$1 = 0;
-			for (const part of decodedParts) {
-				combined.set(part, offset$1);
-				offset$1 += part.length;
-			}
-			body = combined.buffer;
-		}
-	} else if (isJsonMode) {
-		const mergedParts = [];
-		for (const part of dataParts) {
-			const trimmed = part.trim();
-			if (trimmed.length === 0) continue;
-			if (trimmed.startsWith(`[`) && trimmed.endsWith(`]`)) {
-				const inner = trimmed.slice(1, -1).trim();
-				if (inner.length > 0) mergedParts.push(inner);
-			} else mergedParts.push(trimmed);
-		}
-		body = `[${mergedParts.join(`,`)}]`;
-	} else body = dataParts.join(``);
-	return new Response(body, {
-		status: 200,
-		headers
-	});
-}
-/**
 * Resolve headers from HeadersRecord (supports async functions).
 * Unified implementation used by both stream() and DurableStream.
 */
@@ -2486,6 +2264,7 @@ async function streamInternal(options) {
 	const startOffset = options.offset ?? `-1`;
 	fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, startOffset);
 	const live = options.live ?? true;
+	if (live === `long-poll` || live === `sse`) fetchUrl.searchParams.set(LIVE_QUERY_PARAM, live);
 	const params = await resolveParams(options.params);
 	for (const [key, value] of Object.entries(params)) fetchUrl.searchParams.set(key, value);
 	const headers = await resolveHeaders(options.headers);
@@ -2510,11 +2289,12 @@ async function streamInternal(options) {
 	const initialStreamClosed = firstResponse.headers.get(STREAM_CLOSED_HEADER)?.toLowerCase() === `true`;
 	const isJsonMode = options.json === true || (contentType?.includes(`application/json`) ?? false);
 	const encoding = firstResponse.headers.get(STREAM_SSE_DATA_ENCODING_HEADER) === `base64` ? `base64` : void 0;
-	const fetchNext = async (offset, cursor, signal, upToDate, resumingFromPause) => {
+	const fetchNext = async (offset, cursor, signal, resumingFromPause) => {
 		const nextUrl = new URL(url);
 		nextUrl.searchParams.set(OFFSET_QUERY_PARAM, offset);
-		if (upToDate && !resumingFromPause) {
-			if (live === true || live === `long-poll`) nextUrl.searchParams.set(LIVE_QUERY_PARAM, `long-poll`);
+		if (!resumingFromPause) {
+			if (live === `sse`) nextUrl.searchParams.set(LIVE_QUERY_PARAM, `sse`);
+			else if (live === true || live === `long-poll`) nextUrl.searchParams.set(LIVE_QUERY_PARAM, `long-poll`);
 		}
 		if (cursor) nextUrl.searchParams.set(`cursor`, cursor);
 		const nextParams = await resolveParams(options.params);
@@ -2638,7 +2418,6 @@ var IdempotentProducer = class {
 	#maxBatchBytes;
 	#lingerMs;
 	#fetchClient;
-	#headers;
 	#signal;
 	#onError;
 	#pendingBatch = [];
@@ -2646,11 +2425,9 @@ var IdempotentProducer = class {
 	#lingerTimeout = null;
 	#queue;
 	#maxInFlight;
-	#deferredEnqueues = /* @__PURE__ */ new Set();
 	#closed = false;
 	#closeResult = null;
 	#pendingFinalMessage;
-	#lastSuccessfulOffset;
 	#epochClaimed;
 	#seqState = /* @__PURE__ */ new Map();
 	/**
@@ -2676,7 +2453,6 @@ var IdempotentProducer = class {
 		this.#maxBatchBytes = maxBatchBytes;
 		this.#lingerMs = lingerMs;
 		this.#signal = opts?.signal;
-		this.#headers = opts?.headers;
 		this.#onError = opts?.onError;
 		this.#fetchClient = opts?.fetch ?? ((...args) => fetch(...args));
 		this.#maxInFlight = maxInFlight;
@@ -2738,10 +2514,7 @@ var IdempotentProducer = class {
 			this.#lingerTimeout = null;
 		}
 		if (this.#pendingBatch.length > 0) this.#enqueuePendingBatch();
-		do {
-			await this.#queue.drained();
-			await Promise.all(this.#deferredEnqueues);
-		} while (this.#deferredEnqueues.size > 0 || this.inFlightCount > 0);
+		await this.#queue.drained();
 	}
 	/**
 	* Stop the producer without closing the underlying stream.
@@ -2805,13 +2578,13 @@ var IdempotentProducer = class {
 			else body = bodyBytes;
 		}
 		const seqForThisRequest = this.#nextSeq;
-		const headers = await this.#buildHeaders({
+		const headers = {
 			"content-type": contentType,
 			[PRODUCER_ID_HEADER]: this.#producerId,
 			[PRODUCER_EPOCH_HEADER]: this.#epoch.toString(),
 			[PRODUCER_SEQ_HEADER]: seqForThisRequest.toString(),
 			[STREAM_CLOSED_HEADER]: `true`
-		});
+		};
 		const response = await this.#fetchClient(this.#stream.url, {
 			method: `POST`,
 			headers,
@@ -2820,15 +2593,11 @@ var IdempotentProducer = class {
 		});
 		if (response.status === 204) {
 			this.#nextSeq = seqForThisRequest + 1;
-			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
-			this.#recordSuccessfulOffset(finalOffset);
-			return { finalOffset };
+			return { finalOffset: response.headers.get(STREAM_OFFSET_HEADER) ?? `` };
 		}
 		if (response.status === 200) {
 			this.#nextSeq = seqForThisRequest + 1;
-			const finalOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
-			this.#recordSuccessfulOffset(finalOffset);
-			return { finalOffset };
+			return { finalOffset: response.headers.get(STREAM_OFFSET_HEADER) ?? `` };
 		}
 		if (response.status === 403) {
 			const currentEpochStr = response.headers.get(PRODUCER_EPOCH_HEADER);
@@ -2876,14 +2645,7 @@ var IdempotentProducer = class {
 	* Number of batches currently in flight.
 	*/
 	get inFlightCount() {
-		return this.#queue.length() + this.#queue.running();
-	}
-	/**
-	* The greatest non-empty stream offset returned by a successful producer
-	* append or close request.
-	*/
-	get lastSuccessfulOffset() {
-		return this.#lastSuccessfulOffset;
+		return this.#queue.length();
 	}
 	/**
 	* Enqueue the current pending batch for processing.
@@ -2891,22 +2653,17 @@ var IdempotentProducer = class {
 	#enqueuePendingBatch() {
 		if (this.#pendingBatch.length === 0) return;
 		const batch = this.#pendingBatch;
+		const seq = this.#nextSeq;
 		this.#pendingBatch = [];
 		this.#batchBytes = 0;
-		if (this.#autoClaim && !this.#epochClaimed && this.inFlightCount > 0) {
-			const deferred = this.#queue.drained().then(() => {
-				this.#pushBatch(batch);
-			}).finally(() => {
-				this.#deferredEnqueues.delete(deferred);
-			});
-			this.#deferredEnqueues.add(deferred);
-			deferred.catch(() => {});
-		} else this.#pushBatch(batch);
-	}
-	#pushBatch(batch) {
-		const seq = this.#nextSeq;
 		this.#nextSeq++;
-		this.#queue.push({
+		if (this.#autoClaim && !this.#epochClaimed && this.#queue.length() > 0) this.#queue.drained().then(() => {
+			this.#queue.push({
+				batch,
+				seq
+			}).catch(() => {});
+		});
+		else this.#queue.push({
 			batch,
 			seq
 		}).catch(() => {});
@@ -2918,8 +2675,7 @@ var IdempotentProducer = class {
 		const { batch, seq } = task;
 		const epoch = this.#epoch;
 		try {
-			const result = await this.#doSendBatch(batch, seq, epoch);
-			this.#recordSuccessfulOffset(result.offset);
+			await this.#doSendBatch(batch, seq, epoch);
 			if (!this.#epochClaimed) this.#epochClaimed = true;
 			this.#signalSeqComplete(epoch, seq, void 0);
 		} catch (error) {
@@ -2928,9 +2684,6 @@ var IdempotentProducer = class {
 			throw error;
 		}
 	}
-	#recordSuccessfulOffset(offset) {
-		if (offset && (!this.#lastSuccessfulOffset || offset > this.#lastSuccessfulOffset)) this.#lastSuccessfulOffset = offset;
-	}
 	/**
 	* Signal that a sequence has completed (success or failure).
 	*/
@@ -3005,12 +2758,12 @@ var IdempotentProducer = class {
 			batchedBody = concatenated;
 		}
 		const url = this.#stream.url;
-		const headers = await this.#buildHeaders({
+		const headers = {
 			"content-type": contentType,
 			[PRODUCER_ID_HEADER]: this.#producerId,
 			[PRODUCER_EPOCH_HEADER]: epoch.toString(),
 			[PRODUCER_SEQ_HEADER]: seq.toString()
-		});
+		};
 		const response = await this.#fetchClient(url, {
 			method: `POST`,
 			headers,
@@ -3051,15 +2804,6 @@ var IdempotentProducer = class {
 		if (response.status === 400) throw await DurableStreamError.fromResponse(response, url);
 		throw await FetchError.fromResponse(response, url);
 	}
-	async #buildHeaders(protocolHeaders) {
-		const streamHeaders = await this.#stream.resolveHeaders();
-		const producerHeaders = await resolveHeaders(this.#headers);
-		return {
-			...streamHeaders,
-			...producerHeaders,
-			...protocolHeaders
-		};
-	}
 	/**
 	* Clear pending batch and report error.
 	*/
@@ -3103,7 +2847,7 @@ function isPromiseLike(value) {
 *   contentType: "application/json"
 * });
 *
-* // Single write
+* // Write data
 * await stream.append(JSON.stringify({ message: "hello" }));
 *
 * // Read with the new API
@@ -3126,7 +2870,6 @@ var DurableStream = class DurableStream {
 	contentType;
 	#options;
 	#fetchClient;
-	#baseFetchClient;
 	#onError;
 	#batchingEnabled;
 	#queue;
@@ -3147,9 +2890,7 @@ var DurableStream = class DurableStream {
 		if (opts.contentType) this.contentType = opts.contentType;
 		this.#batchingEnabled = opts.batching !== false;
 		if (this.#batchingEnabled) this.#queue = import_queue.default.promise(this.#batchWorker.bind(this), 1);
-		this.#baseFetchClient = opts.fetch ?? ((...args) => fetch(...args));
-		const backOffOpts = { ...opts.backoffOptions ?? BackoffDefaults };
-		const fetchWithBackoffClient = createFetchWithBackoff(this.#baseFetchClient, backOffOpts);
+		const fetchWithBackoffClient = createFetchWithBackoff(opts.fetch ?? ((...args) => fetch(...args)), { ...opts.backoffOptions ?? BackoffDefaults });
 		this.#fetchClient = createFetchWithConsumedBody(fetchWithBackoffClient);
 	}
 	/**
@@ -3204,15 +2945,12 @@ var DurableStream = class DurableStream {
 	*/
 	async head(opts) {
 		const { requestHeaders, fetchUrl } = await this.#buildRequest();
-		const response = await this.#baseFetchClient(fetchUrl.toString(), {
+		const response = await this.#fetchClient(fetchUrl.toString(), {
 			method: `HEAD`,
 			headers: requestHeaders,
 			signal: opts?.signal ?? this.#options.signal
 		});
-		if (!response.ok) {
-			if (response.status === 404) return { exists: false };
-			await handleErrorResponse(response, this.url);
-		}
+		if (!response.ok) await handleErrorResponse(response, this.url);
 		const contentType = response.headers.get(`content-type`) ?? void 0;
 		const offset = response.headers.get(STREAM_OFFSET_HEADER) ?? void 0;
 		const etag = response.headers.get(`etag`) ?? void 0;
@@ -3310,14 +3048,9 @@ var DurableStream = class DurableStream {
 	/**
 	* Append a single payload to the stream.
 	*
-	* Batching: when batching is enabled (default), append() calls that overlap
-	* in time (e.g. fired without awaiting each one) are coalesced into a
-	* single POST while a prior POST is in flight. If every call is awaited
-	* before the next is issued, no batching happens — each call becomes its
-	* own roundtrip. For tight loops driving an async iterable (e.g. LLM
-	* token streams), prefer `appendStream()` / `writable()` which pipe the
-	* source over a single POST, or fire `append()` calls without awaiting
-	* each one and await the last promise (and `close()`) at the end.
+	* When batching is enabled (default), multiple append() calls made while
+	* a POST is in-flight will be batched together into a single request.
+	* This significantly improves throughput for high-frequency writes.
 	*
 	* - `body` must be string or Uint8Array.
 	* - For JSON streams, pass pre-serialized JSON strings.
@@ -3327,7 +3060,7 @@ var DurableStream = class DurableStream {
 	*
 	* @example
 	* ```typescript
-	* // JSON stream - pass pre-serialized JSON (single write)
+	* // JSON stream - pass pre-serialized JSON
 	* await stream.append(JSON.stringify({ message: "hello" }));
 	*
 	* // Byte stream
@@ -3336,14 +3069,6 @@ var DurableStream = class DurableStream {
 	*
 	* // Promise value - awaited before buffering
 	* await stream.append(fetchData());
-	*
-	* // High-frequency writes from an async iterable - fire-and-track-last
-	* let last: Promise<void> = Promise.resolve();
-	* for await (const chunk of source) {
-	*   last = stream.append(JSON.stringify(chunk));
-	* }
-	* await last;
-	* await stream.close();
 	* ```
 	*/
 	async append(body, opts) {
@@ -3550,7 +3275,6 @@ var DurableStream = class DurableStream {
 		let writeError = null;
 		const producer = new IdempotentProducer(this, producerId, {
 			autoClaim: true,
-			headers: opts?.headers,
 			lingerMs: opts?.lingerMs,
 			maxBatchBytes: opts?.maxBatchBytes,
 			onError: (error) => {
@@ -3633,14 +3357,6 @@ var DurableStream = class DurableStream {
 		});
 	}
 	/**
-	* Resolve the stream's configured headers.
-	* Used by IdempotentProducer to merge auth headers into its requests.
-	* @internal
-	*/
-	async resolveHeaders() {
-		return resolveHeaders(this.#options.headers);
-	}
-	/**
 	* Build request headers and URL.
 	*/
 	async #buildRequest() {