@durable-streams/client 0.1.3 → 0.1.4

package/README.md

@@ -10,14 +10,17 @@ npm install @durable-streams/client
 
 ## Overview
 
-The Durable Streams client provides two main APIs:
+The Durable Streams client provides three main APIs:
 
 1. **`stream()` function** - A fetch-like read-only API for consuming streams
 2. **`DurableStream` class** - A handle for read/write operations on a stream
+3. **`IdempotentProducer` class** - High-throughput producer with exactly-once write semantics (recommended for writes)
 
 ## Key Features
 
-- **Automatic Batching**: Multiple `append()` calls are automatically batched together when a POST is in-flight, significantly improving throughput for high-frequency writes
+- **Exactly-Once Writes**: `IdempotentProducer` provides Kafka-style exactly-once semantics with automatic deduplication
+- **Automatic Batching**: Multiple writes are automatically batched together for high throughput
+- **Pipelining**: Up to 5 concurrent batches in flight by default for maximum throughput
 - **Streaming Reads**: `stream()` and `DurableStream.stream()` provide rich consumption options (promises, ReadableStreams, subscribers)
 - **Resumable**: Offset-based reads let you resume from any point
 - **Real-time**: Long-poll and SSE modes for live tailing with catch-up from any offset
@@ -81,9 +84,56 @@ const unsubscribe3 = res.subscribeText(async (chunk) => {
 })
 ```
 
+### High-Throughput Writes: Using `IdempotentProducer` (Recommended)
+
+For reliable, high-throughput writes with exactly-once semantics, use `IdempotentProducer`:
+
+```typescript
+import { DurableStream, IdempotentProducer } from "@durable-streams/client"
+
+const stream = await DurableStream.create({
+  url: "https://streams.example.com/events",
+  contentType: "application/json",
+})
+
+const producer = new IdempotentProducer(stream, "event-processor-1", {
+  autoClaim: true,
+  onError: (err) => console.error("Batch failed:", err), // Errors reported here
+})
+
+// Fire-and-forget - don't await, errors go to onError callback
+for (const event of events) {
+  producer.append(event) // Objects serialized automatically for JSON streams
+}
+
+// IMPORTANT: Always flush before shutdown to ensure delivery
+await producer.flush()
+await producer.close()
+```
+
+For high-throughput scenarios, `append()` is fire-and-forget (returns immediately):
+
+```typescript
+// Fire-and-forget - errors reported via onError callback
+for (const event of events) {
+  producer.append(event) // Returns void, adds to batch
+}
+
+// Always flush before shutdown to ensure delivery
+await producer.flush()
+```
+
+**Why use IdempotentProducer?**
+
+- **Exactly-once delivery**: Server deduplicates using `(producerId, epoch, seq)` tuple
+- **Automatic batching**: Multiple writes batched into single HTTP requests
+- **Pipelining**: Multiple batches in flight concurrently
+- **Zombie fencing**: Stale producers are rejected, preventing split-brain scenarios
+- **Network resilience**: Safe to retry on network errors (server deduplicates)
+
 ### Read/Write: Using `DurableStream`
 
-For write operations or when you need a persistent handle:
+For simple write operations or when you need a persistent handle:
 
 ```typescript
 import { DurableStream } from "@durable-streams/client"
@@ -98,7 +148,7 @@ const handle = await DurableStream.create({
   ttlSeconds: 3600,
 })
 
-// Append data
+// Append data (simple API without exactly-once guarantees)
 await handle.append(JSON.stringify({ type: "message", text: "Hello" }), {
   seq: "writer-1-000001",
 })
@@ -787,6 +837,117 @@ res.subscribeJson(async (batch) => {
 
 ---
 
+## IdempotentProducer
+
+The `IdempotentProducer` class provides Kafka-style exactly-once write semantics with automatic batching and pipelining.
+
+### Constructor
+
+```typescript
+new IdempotentProducer(stream: DurableStream, producerId: string, opts?: IdempotentProducerOptions)
+```
+
+**Parameters:**
+
+- `stream` - The DurableStream to write to
+- `producerId` - Stable identifier for this producer (e.g., "order-service-1")
+- `opts` - Optional configuration
+
+**Options:**
+
+```typescript
+interface IdempotentProducerOptions {
+  epoch?: number // Starting epoch (default: 0)
+  autoClaim?: boolean // On 403, retry with epoch+1 (default: false)
+  maxBatchBytes?: number // Max bytes before sending batch (default: 1MB)
+  lingerMs?: number // Max time to wait for more messages (default: 5ms)
+  maxInFlight?: number // Concurrent batches in flight (default: 5)
+  signal?: AbortSignal // Cancellation signal
+  fetch?: typeof fetch // Custom fetch implementation
+  onError?: (error: Error) => void // Error callback for batch failures
+}
+```
+
+### Methods
+
+#### `append(body): void`
+
+Append data to the stream (fire-and-forget). For JSON streams, you can pass objects directly.
+Returns immediately after adding to the internal batch. Errors are reported via `onError` callback.
+
+```typescript
+// For JSON streams - pass objects directly
+producer.append({ event: "click", x: 100 })
+
+// Or strings/bytes
+producer.append("message data")
+producer.append(new Uint8Array([1, 2, 3]))
+
+// All appends are fire-and-forget - use flush() to wait for delivery
+await producer.flush()
+```
+
+#### `flush(): Promise<void>`
+
+Send any pending batch immediately and wait for all in-flight batches to complete.
+
+```typescript
+// Always call before shutdown
+await producer.flush()
+```
+
+#### `close(): Promise<void>`
+
+Flush pending messages and close the producer. Further `append()` calls will throw.
+
+```typescript
+await producer.close()
+```
+
+#### `restart(): Promise<void>`
+
+Increment epoch and reset sequence. Call this when restarting the producer to establish a new session.
+
+```typescript
+await producer.restart()
+```
+
+### Properties
+
+- `epoch: number` - Current epoch for this producer
+- `nextSeq: number` - Next sequence number to be assigned
+- `pendingCount: number` - Messages in the current pending batch
+- `inFlightCount: number` - Batches currently in flight
+
+### Error Handling
+
+Errors are delivered via the `onError` callback since `append()` is fire-and-forget:
+
+```typescript
+import {
+  IdempotentProducer,
+  StaleEpochError,
+  SequenceGapError,
+} from "@durable-streams/client"
+
+const producer = new IdempotentProducer(stream, "my-producer", {
+  onError: (error) => {
+    if (error instanceof StaleEpochError) {
+      // Another producer has a higher epoch - this producer is "fenced"
+      console.log(`Fenced by epoch ${error.currentEpoch}`)
+    } else if (error instanceof SequenceGapError) {
+      // Sequence gap detected (should not happen with proper usage)
+      console.log(`Expected seq ${error.expectedSeq}, got ${error.receivedSeq}`)
+    }
+  },
+})
+
+producer.append("data") // Fire-and-forget, errors go to onError
+await producer.flush() // Wait for all batches to complete
+```
+
+---
+
 ## Types
 
 Key types exported from the package:
@@ -797,6 +958,9 @@ Key types exported from the package:
 - `JsonBatch<T>` - `{ items: T[], offset: Offset, upToDate: boolean, cursor?: string }`
 - `TextChunk` - `{ text: string, offset: Offset, upToDate: boolean, cursor?: string }`
 - `HeadResult` - Metadata from HEAD requests
+- `IdempotentProducer` - Exactly-once producer class
+- `StaleEpochError` - Thrown when producer epoch is stale (zombie fencing)
+- `SequenceGapError` - Thrown when sequence numbers are out of order
 - `DurableStreamError` - Protocol-level errors with codes
 - `FetchError` - Transport/network errors
 

package/dist/index.cjs

@@ -59,6 +59,28 @@ const STREAM_TTL_HEADER = `Stream-TTL`;
 */
 const STREAM_EXPIRES_AT_HEADER = `Stream-Expires-At`;
 /**
+* Request header for producer ID (client-supplied stable identifier).
+*/
+const PRODUCER_ID_HEADER = `Producer-Id`;
+/**
+* Request/response header for producer epoch.
+* Client-declared, server-validated monotonically increasing.
+*/
+const PRODUCER_EPOCH_HEADER = `Producer-Epoch`;
+/**
+* Request header for producer sequence number.
+* Monotonically increasing per epoch, per-batch (not per-message).
+*/
+const PRODUCER_SEQ_HEADER = `Producer-Seq`;
+/**
+* Response header indicating expected sequence number on 409 Conflict.
+*/
+const PRODUCER_EXPECTED_SEQ_HEADER = `Producer-Expected-Seq`;
+/**
+* Response header indicating received sequence number on 409 Conflict.
+*/
+const PRODUCER_RECEIVED_SEQ_HEADER = `Producer-Received-Seq`;
+/**
 * Query parameter for starting offset.
 */
 const OFFSET_QUERY_PARAM = `offset`;
@@ -1406,7 +1428,7 @@ async function streamInternal(options) {
 * Normalize content-type by extracting the media type (before any semicolon).
 * Handles cases like "application/json; charset=utf-8".
 */
-function normalizeContentType(contentType) {
+function normalizeContentType$1(contentType) {
 	if (!contentType) return ``;
 	return contentType.split(`;`)[0].trim().toLowerCase();
 }
@@ -1472,6 +1494,7 @@ var DurableStream = class DurableStream {
 			url: urlStr
 		};
 		this.#onError = opts.onError;
+		if (opts.contentType) this.contentType = opts.contentType;
 		this.#batchingEnabled = opts.batching !== false;
 		if (this.#batchingEnabled) this.#queue = fastq.default.promise(this.#batchWorker.bind(this), 1);
 		const baseFetchClient = opts.fetch ?? ((...args) => fetch(...args));
@@ -1620,7 +1643,7 @@ var DurableStream = class DurableStream {
 		const contentType = opts?.contentType ?? this.#options.contentType ?? this.contentType;
 		if (contentType) requestHeaders[`content-type`] = contentType;
 		if (opts?.seq) requestHeaders[STREAM_SEQ_HEADER] = opts.seq;
-		const isJson = normalizeContentType(contentType) === `application/json`;
+		const isJson = normalizeContentType$1(contentType) === `application/json`;
 		const bodyToEncode = isJson ? [body] : body;
 		const encodedBody = encodeBody(bodyToEncode);
 		const response = await this.#fetchClient(fetchUrl.toString(), {
@@ -1686,7 +1709,7 @@ var DurableStream = class DurableStream {
 			break;
 		}
 		if (highestSeq) requestHeaders[STREAM_SEQ_HEADER] = highestSeq;
-		const isJson = normalizeContentType(contentType) === `application/json`;
+		const isJson = normalizeContentType$1(contentType) === `application/json`;
 		let batchedBody;
 		if (isJson) {
 			const values = batch.map((m) => m.data);
@@ -1925,6 +1948,403 @@ function validateOptions(options) {
 	warnIfUsingHttpInBrowser(options.url, options.warnOnHttp);
 }
 
+//#endregion
+//#region src/idempotent-producer.ts
+/**
+* Error thrown when a producer's epoch is stale (zombie fencing).
+*/
+var StaleEpochError = class extends Error {
+	/**
+	* The current epoch on the server.
+	*/
+	currentEpoch;
+	constructor(currentEpoch) {
+		super(`Producer epoch is stale. Current server epoch: ${currentEpoch}. Call restart() or create a new producer with a higher epoch.`);
+		this.name = `StaleEpochError`;
+		this.currentEpoch = currentEpoch;
+	}
+};
+/**
+* Error thrown when an unrecoverable sequence gap is detected.
+*
+* With maxInFlight > 1, HTTP requests can arrive out of order at the server,
+* causing temporary 409 responses. The client automatically handles these
+* by waiting for earlier sequences to complete, then retrying.
+*
+* This error is only thrown when the gap cannot be resolved (e.g., the
+* expected sequence is >= our sequence, indicating a true protocol violation).
+*/
+var SequenceGapError = class extends Error {
+	expectedSeq;
+	receivedSeq;
+	constructor(expectedSeq, receivedSeq) {
+		super(`Producer sequence gap: expected ${expectedSeq}, received ${receivedSeq}`);
+		this.name = `SequenceGapError`;
+		this.expectedSeq = expectedSeq;
+		this.receivedSeq = receivedSeq;
+	}
+};
+/**
+* Normalize content-type by extracting the media type (before any semicolon).
+*/
+function normalizeContentType(contentType) {
+	if (!contentType) return ``;
+	return contentType.split(`;`)[0].trim().toLowerCase();
+}
+/**
+* An idempotent producer for exactly-once writes to a durable stream.
+*
+* Features:
+* - Fire-and-forget: append() returns immediately, batches in background
+* - Exactly-once: server deduplicates using (producerId, epoch, seq)
+* - Batching: multiple appends batched into single HTTP request
+* - Pipelining: up to maxInFlight concurrent batches
+* - Zombie fencing: stale producers rejected via epoch validation
+*
+* @example
+* ```typescript
+* const stream = new DurableStream({ url: "https://..." });
+* const producer = new IdempotentProducer(stream, "order-service-1", {
+*   epoch: 0,
+*   autoClaim: true,
+* });
+*
+* // Fire-and-forget writes (synchronous, returns immediately)
+* producer.append("message 1");
+* producer.append("message 2");
+*
+* // Ensure all messages are delivered before shutdown
+* await producer.flush();
+* await producer.close();
+* ```
+*/
+var IdempotentProducer = class {
+	#stream;
+	#producerId;
+	#epoch;
+	#nextSeq = 0;
+	#autoClaim;
+	#maxBatchBytes;
+	#lingerMs;
+	#fetchClient;
+	#signal;
+	#onError;
+	#pendingBatch = [];
+	#batchBytes = 0;
+	#lingerTimeout = null;
+	#queue;
+	#maxInFlight;
+	#closed = false;
+	#epochClaimed;
+	#seqState = new Map();
+	/**
+	* Create an idempotent producer for a stream.
+	*
+	* @param stream - The DurableStream to write to
+	* @param producerId - Stable identifier for this producer (e.g., "order-service-1")
+	* @param opts - Producer options
+	*/
+	constructor(stream$1, producerId, opts) {
+		this.#stream = stream$1;
+		this.#producerId = producerId;
+		this.#epoch = opts?.epoch ?? 0;
+		this.#autoClaim = opts?.autoClaim ?? false;
+		this.#maxBatchBytes = opts?.maxBatchBytes ?? 1024 * 1024;
+		this.#lingerMs = opts?.lingerMs ?? 5;
+		this.#signal = opts?.signal;
+		this.#onError = opts?.onError;
+		this.#fetchClient = opts?.fetch ?? ((...args) => fetch(...args));
+		this.#maxInFlight = opts?.maxInFlight ?? 5;
+		this.#epochClaimed = !this.#autoClaim;
+		this.#queue = fastq.default.promise(this.#batchWorker.bind(this), this.#maxInFlight);
+		if (this.#signal) this.#signal.addEventListener(`abort`, () => {
+			this.#rejectPendingBatch(new DurableStreamError(`Producer aborted`, `ALREADY_CLOSED`, void 0, void 0));
+		}, { once: true });
+	}
+	/**
+	* Append data to the stream.
+	*
+	* This is fire-and-forget: returns immediately after adding to the batch.
+	* The message is batched and sent when:
+	* - maxBatchBytes is reached
+	* - lingerMs elapses
+	* - flush() is called
+	*
+	* Errors are reported via onError callback if configured. Use flush() to
+	* wait for all pending messages to be sent.
+	*
+	* For JSON streams, pass native objects (which will be serialized internally).
+	* For byte streams, pass string or Uint8Array.
+	*
+	* @param body - Data to append (object for JSON streams, string or Uint8Array for byte streams)
+	*/
+	append(body) {
+		if (this.#closed) throw new DurableStreamError(`Producer is closed`, `ALREADY_CLOSED`, void 0, void 0);
+		const isJson = normalizeContentType(this.#stream.contentType) === `application/json`;
+		let bytes;
+		let data;
+		if (isJson) {
+			const json = JSON.stringify(body);
+			bytes = new TextEncoder().encode(json);
+			data = body;
+		} else {
+			if (typeof body === `string`) bytes = new TextEncoder().encode(body);
+			else if (body instanceof Uint8Array) bytes = body;
+			else throw new DurableStreamError(`Non-JSON streams require string or Uint8Array`, `BAD_REQUEST`, 400, void 0);
+			data = bytes;
+		}
+		this.#pendingBatch.push({
+			data,
+			body: bytes
+		});
+		this.#batchBytes += bytes.length;
+		if (this.#batchBytes >= this.#maxBatchBytes) this.#enqueuePendingBatch();
+		else if (!this.#lingerTimeout) this.#lingerTimeout = setTimeout(() => {
+			this.#lingerTimeout = null;
+			if (this.#pendingBatch.length > 0) this.#enqueuePendingBatch();
+		}, this.#lingerMs);
+	}
+	/**
+	* Send any pending batch immediately and wait for all in-flight batches.
+	*
+	* Call this before shutdown to ensure all messages are delivered.
+	*/
+	async flush() {
+		if (this.#lingerTimeout) {
+			clearTimeout(this.#lingerTimeout);
+			this.#lingerTimeout = null;
+		}
+		if (this.#pendingBatch.length > 0) this.#enqueuePendingBatch();
+		await this.#queue.drained();
+	}
+	/**
+	* Flush pending messages and close the producer.
+	*
+	* After calling close(), further append() calls will throw.
+	*/
+	async close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		try {
+			await this.flush();
+		} catch {}
+	}
+	/**
+	* Increment epoch and reset sequence.
+	*
+	* Call this when restarting the producer to establish a new session.
+	* Flushes any pending messages first.
+	*/
+	async restart() {
+		await this.flush();
+		this.#epoch++;
+		this.#nextSeq = 0;
+	}
+	/**
+	* Current epoch for this producer.
+	*/
+	get epoch() {
+		return this.#epoch;
+	}
+	/**
+	* Next sequence number to be assigned.
+	*/
+	get nextSeq() {
+		return this.#nextSeq;
+	}
+	/**
+	* Number of messages in the current pending batch.
+	*/
+	get pendingCount() {
+		return this.#pendingBatch.length;
+	}
+	/**
+	* Number of batches currently in flight.
+	*/
+	get inFlightCount() {
+		return this.#queue.length();
+	}
+	/**
+	* Enqueue the current pending batch for processing.
+	*/
+	#enqueuePendingBatch() {
+		if (this.#pendingBatch.length === 0) return;
+		const batch = this.#pendingBatch;
+		const seq = this.#nextSeq;
+		this.#pendingBatch = [];
+		this.#batchBytes = 0;
+		this.#nextSeq++;
+		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(() => {});
+	}
+	/**
+	* Batch worker - processes batches via fastq.
+	*/
+	async #batchWorker(task) {
+		const { batch, seq } = task;
+		const epoch = this.#epoch;
+		try {
+			await this.#doSendBatch(batch, seq, epoch);
+			if (!this.#epochClaimed) this.#epochClaimed = true;
+			this.#signalSeqComplete(epoch, seq, void 0);
+		} catch (error) {
+			this.#signalSeqComplete(epoch, seq, error);
+			if (this.#onError) this.#onError(error);
+			throw error;
+		}
+	}
+	/**
+	* Signal that a sequence has completed (success or failure).
+	*/
+	#signalSeqComplete(epoch, seq, error) {
+		let epochMap = this.#seqState.get(epoch);
+		if (!epochMap) {
+			epochMap = new Map();
+			this.#seqState.set(epoch, epochMap);
+		}
+		const state = epochMap.get(seq);
+		if (state) {
+			state.resolved = true;
+			state.error = error;
+			for (const waiter of state.waiters) waiter(error);
+			state.waiters = [];
+		} else epochMap.set(seq, {
+			resolved: true,
+			error,
+			waiters: []
+		});
+		const cleanupThreshold = seq - this.#maxInFlight * 3;
+		if (cleanupThreshold > 0) {
+			for (const oldSeq of epochMap.keys()) if (oldSeq < cleanupThreshold) epochMap.delete(oldSeq);
+		}
+	}
+	/**
+	* Wait for a specific sequence to complete.
+	* Returns immediately if already completed.
+	* Throws if the sequence failed.
+	*/
+	#waitForSeq(epoch, seq) {
+		let epochMap = this.#seqState.get(epoch);
+		if (!epochMap) {
+			epochMap = new Map();
+			this.#seqState.set(epoch, epochMap);
+		}
+		const state = epochMap.get(seq);
+		if (state?.resolved) {
+			if (state.error) return Promise.reject(state.error);
+			return Promise.resolve();
+		}
+		return new Promise((resolve, reject) => {
+			const waiter = (err) => {
+				if (err) reject(err);
+				else resolve();
+			};
+			if (state) state.waiters.push(waiter);
+			else epochMap.set(seq, {
+				resolved: false,
+				waiters: [waiter]
+			});
+		});
+	}
+	/**
+	* Actually send the batch to the server.
+	* Handles auto-claim retry on 403 (stale epoch) if autoClaim is enabled.
+	* Does NOT implement general retry/backoff for network errors or 5xx responses.
+	*/
+	async #doSendBatch(batch, seq, epoch) {
+		const contentType = this.#stream.contentType ?? `application/octet-stream`;
+		const isJson = normalizeContentType(contentType) === `application/json`;
+		let batchedBody;
+		if (isJson) {
+			const values = batch.map((e) => e.data);
+			batchedBody = JSON.stringify(values);
+		} else {
+			const totalSize = batch.reduce((sum, e) => sum + e.body.length, 0);
+			const concatenated = new Uint8Array(totalSize);
+			let offset = 0;
+			for (const entry of batch) {
+				concatenated.set(entry.body, offset);
+				offset += entry.body.length;
+			}
+			batchedBody = concatenated;
+		}
+		const url = this.#stream.url;
+		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,
+			body: batchedBody,
+			signal: this.#signal
+		});
+		if (response.status === 204) return {
+			offset: ``,
+			duplicate: true
+		};
+		if (response.status === 200) {
+			const resultOffset = response.headers.get(STREAM_OFFSET_HEADER) ?? ``;
+			return {
+				offset: resultOffset,
+				duplicate: false
+			};
+		}
+		if (response.status === 403) {
+			const currentEpochStr = response.headers.get(PRODUCER_EPOCH_HEADER);
+			const currentEpoch = currentEpochStr ? parseInt(currentEpochStr, 10) : epoch;
+			if (this.#autoClaim) {
+				const newEpoch = currentEpoch + 1;
+				this.#epoch = newEpoch;
+				this.#nextSeq = 1;
+				return this.#doSendBatch(batch, 0, newEpoch);
+			}
+			throw new StaleEpochError(currentEpoch);
+		}
+		if (response.status === 409) {
+			const expectedSeqStr = response.headers.get(PRODUCER_EXPECTED_SEQ_HEADER);
+			const expectedSeq = expectedSeqStr ? parseInt(expectedSeqStr, 10) : 0;
+			if (expectedSeq < seq) {
+				const waitPromises = [];
+				for (let s = expectedSeq; s < seq; s++) waitPromises.push(this.#waitForSeq(epoch, s));
+				await Promise.all(waitPromises);
+				return this.#doSendBatch(batch, seq, epoch);
+			}
+			const receivedSeqStr = response.headers.get(PRODUCER_RECEIVED_SEQ_HEADER);
+			const receivedSeq = receivedSeqStr ? parseInt(receivedSeqStr, 10) : seq;
+			throw new SequenceGapError(expectedSeq, receivedSeq);
+		}
+		if (response.status === 400) {
+			const error$1 = await DurableStreamError.fromResponse(response, url);
+			throw error$1;
+		}
+		const error = await FetchError.fromResponse(response, url);
+		throw error;
+	}
+	/**
+	* Clear pending batch and report error.
+	*/
+	#rejectPendingBatch(error) {
+		if (this.#onError && this.#pendingBatch.length > 0) this.#onError(error);
+		this.#pendingBatch = [];
+		this.#batchBytes = 0;
+		if (this.#lingerTimeout) {
+			clearTimeout(this.#lingerTimeout);
+			this.#lingerTimeout = null;
+		}
+	}
+};
+
 //#endregion
 exports.BackoffDefaults = BackoffDefaults
 exports.CURSOR_QUERY_PARAM = CURSOR_QUERY_PARAM
@@ -1933,10 +2353,16 @@ exports.DurableStream = DurableStream
 exports.DurableStreamError = DurableStreamError
 exports.FetchBackoffAbortError = FetchBackoffAbortError
 exports.FetchError = FetchError
+exports.IdempotentProducer = IdempotentProducer
 exports.InvalidSignalError = InvalidSignalError
 exports.LIVE_QUERY_PARAM = LIVE_QUERY_PARAM
 exports.MissingStreamUrlError = MissingStreamUrlError
 exports.OFFSET_QUERY_PARAM = OFFSET_QUERY_PARAM
+exports.PRODUCER_EPOCH_HEADER = PRODUCER_EPOCH_HEADER
+exports.PRODUCER_EXPECTED_SEQ_HEADER = PRODUCER_EXPECTED_SEQ_HEADER
+exports.PRODUCER_ID_HEADER = PRODUCER_ID_HEADER
+exports.PRODUCER_RECEIVED_SEQ_HEADER = PRODUCER_RECEIVED_SEQ_HEADER
+exports.PRODUCER_SEQ_HEADER = PRODUCER_SEQ_HEADER
 exports.SSE_COMPATIBLE_CONTENT_TYPES = SSE_COMPATIBLE_CONTENT_TYPES
 exports.STREAM_CURSOR_HEADER = STREAM_CURSOR_HEADER
 exports.STREAM_EXPIRES_AT_HEADER = STREAM_EXPIRES_AT_HEADER
@@ -1944,6 +2370,8 @@ exports.STREAM_OFFSET_HEADER = STREAM_OFFSET_HEADER
 exports.STREAM_SEQ_HEADER = STREAM_SEQ_HEADER
 exports.STREAM_TTL_HEADER = STREAM_TTL_HEADER
 exports.STREAM_UP_TO_DATE_HEADER = STREAM_UP_TO_DATE_HEADER
+exports.SequenceGapError = SequenceGapError
+exports.StaleEpochError = StaleEpochError
 exports._resetHttpWarningForTesting = _resetHttpWarningForTesting
 exports.asAsyncIterableReadableStream = asAsyncIterableReadableStream
 exports.createFetchWithBackoff = createFetchWithBackoff