@durable-streams/client-conformance-tests 0.1.9 → 0.2.1

package/dist/{protocol-JuFzdV5x.d.ts → protocol-COHkkGmU.d.cts}

@@ -36,6 +36,10 @@ interface CreateCommand {
   expiresAt?: string;
   /** Custom headers to include */
   headers?: Record<string, string>;
+  /** Create the stream in closed state */
+  closed?: boolean;
+  /** Initial body data to include on creation */
+  data?: string;
 }
 /**
 * Connect to an existing stream without creating it.
@@ -103,6 +107,36 @@ interface IdempotentAppendBatchCommand {
   headers?: Record<string, string>;
 }
 /**
+* Close a stream via IdempotentProducer (uses producer headers for idempotency).
+*/
+interface IdempotentCloseCommand {
+  type: `idempotent-close`;
+  path: string;
+  /** Producer ID */
+  producerId: string;
+  /** Producer epoch */
+  epoch: number;
+  /** Optional final message to append atomically with close */
+  data?: string;
+  /** Auto-claim epoch on 403 */
+  autoClaim: boolean;
+  /** Custom headers to include */
+  headers?: Record<string, string>;
+}
+/**
+* Detach an IdempotentProducer (stop without closing stream).
+*/
+interface IdempotentDetachCommand {
+  type: `idempotent-detach`;
+  path: string;
+  /** Producer ID */
+  producerId: string;
+  /** Producer epoch */
+  epoch: number;
+  /** Custom headers to include */
+  headers?: Record<string, string>;
+}
+/**
 * Read from a stream (GET request).
 */
 interface ReadCommand {
@@ -138,6 +172,33 @@ interface DeleteCommand {
   headers?: Record<string, string>;
 }
 /**
+* Close a stream (no more appends allowed).
+*/
+interface CloseCommand {
+  type: `close`;
+  /** Stream path */
+  path: string;
+  /** Optional final message to append */
+  data?: string;
+  /** Content type for the final message */
+  contentType?: string;
+}
+/**
+* Close a stream via direct HTTP (bypasses client adapter).
+* Used for testing server-side stream closure behavior.
+*/
+interface ServerCloseCommand {
+  type: `server-close`;
+  /** Stream path */
+  path: string;
+  /** Whether stream should be closed (always true for this command) */
+  streamClosed: true;
+  /** Optional body data */
+  data?: string;
+  /** Content type for the body */
+  contentType?: string;
+}
+/**
 * Shutdown the client adapter gracefully.
 */
 interface ShutdownCommand {
@@ -280,7 +341,7 @@ interface BenchmarkThroughputReadOp {
 /**
 * All possible commands from test runner to client.
 */
-type TestCommand = InitCommand | CreateCommand | ConnectCommand | AppendCommand | IdempotentAppendCommand | IdempotentAppendBatchCommand | ReadCommand | HeadCommand | DeleteCommand | ShutdownCommand | SetDynamicHeaderCommand | SetDynamicParamCommand | ClearDynamicCommand | BenchmarkCommand | ValidateCommand;
+type TestCommand = InitCommand | CreateCommand | ConnectCommand | AppendCommand | IdempotentAppendCommand | IdempotentAppendBatchCommand | IdempotentCloseCommand | IdempotentDetachCommand | ReadCommand | HeadCommand | DeleteCommand | CloseCommand | ServerCloseCommand | ShutdownCommand | SetDynamicHeaderCommand | SetDynamicParamCommand | ClearDynamicCommand | BenchmarkCommand | ValidateCommand;
 /**
 * Successful initialization result.
 */
@@ -387,6 +448,24 @@ interface IdempotentAppendBatchResult {
   producerSeq?: number;
 }
 /**
+* Successful idempotent-close result.
+*/
+interface IdempotentCloseResult {
+  type: `idempotent-close`;
+  success: true;
+  status: number;
+  /** Final stream offset after close */
+  finalOffset?: string;
+}
+/**
+* Successful idempotent-detach result.
+*/
+interface IdempotentDetachResult {
+  type: `idempotent-detach`;
+  success: true;
+  status: number;
+}
+/**
 * A chunk of data read from the stream.
 */
 interface ReadChunk {
@@ -410,6 +489,8 @@ interface ReadResult {
   offset?: string;
   /** Whether stream is up-to-date (caught up to head) */
   upToDate?: boolean;
+  /** Whether the stream has been permanently closed (no more appends) */
+  streamClosed?: boolean;
   /** Cursor value if provided */
   cursor?: string;
   /** Response headers */
@@ -434,6 +515,8 @@ interface HeadResult {
   ttlSeconds?: number;
   /** Absolute expiry (ISO 8601) */
   expiresAt?: string;
+  /** Whether the stream has been permanently closed (no more appends) */
+  streamClosed?: boolean;
   headers?: Record<string, string>;
 }
 /**
@@ -446,6 +529,15 @@ interface DeleteResult {
   headers?: Record<string, string>;
 }
 /**
+* Successful close result.
+*/
+interface CloseResult {
+  type: `close`;
+  success: true;
+  /** Final offset after closing (may include final message) */
+  finalOffset: string;
+}
+/**
 * Successful shutdown result.
 */
 interface ShutdownResult {
@@ -521,7 +613,7 @@ interface ErrorResult {
 /**
 * All possible results from client to test runner.
 */
-type TestResult = InitResult | CreateResult | ConnectResult | AppendResult | IdempotentAppendResult | IdempotentAppendBatchResult | ReadResult | HeadResult | DeleteResult | ShutdownResult | SetDynamicHeaderResult | SetDynamicParamResult | ClearDynamicResult | ValidateResult | BenchmarkResult | ErrorResult;
+type TestResult = InitResult | CreateResult | ConnectResult | AppendResult | IdempotentAppendResult | IdempotentAppendBatchResult | IdempotentCloseResult | IdempotentDetachResult | ReadResult | HeadResult | DeleteResult | CloseResult | ShutdownResult | SetDynamicHeaderResult | SetDynamicParamResult | ClearDynamicResult | ValidateResult | BenchmarkResult | ErrorResult;
 /**
 * Parse a JSON line into a TestCommand.
 */
@@ -560,6 +652,8 @@ declare const ErrorCodes: {
   readonly NOT_FOUND: "NOT_FOUND";
   /** Sequence number conflict (409) */
   readonly SEQUENCE_CONFLICT: "SEQUENCE_CONFLICT";
+  /** Stream is closed (409 with Stream-Closed header) */
+  readonly STREAM_CLOSED: "STREAM_CLOSED";
   /** Invalid offset format */
   readonly INVALID_OFFSET: "INVALID_OFFSET";
   /** Server returned unexpected status */
@@ -607,4 +701,4 @@ declare function calculateStats(durationsNs: Array<bigint>): BenchmarkStats;
 * Format a BenchmarkStats object for display.
 */
 declare function formatStats(stats: BenchmarkStats, unit?: string): Record<string, string>; //#endregion
-export { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes as ErrorCodes$1, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats as calculateStats$1, decodeBase64 as decodeBase64$1, encodeBase64 as encodeBase64$1, formatStats as formatStats$1, parseCommand as parseCommand$1, parseResult as parseResult$1, serializeCommand as serializeCommand$1, serializeResult as serializeResult$1 };
+export { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, CloseCommand, CloseResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, IdempotentCloseCommand, IdempotentCloseResult, IdempotentDetachCommand, IdempotentDetachResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, ServerCloseCommand, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult };

package/dist/{protocol-IioVPNaP.cjs → protocol-sDk3deGa.cjs}

@@ -46,6 +46,7 @@ const ErrorCodes = {
 	CONFLICT: `CONFLICT`,
 	NOT_FOUND: `NOT_FOUND`,
 	SEQUENCE_CONFLICT: `SEQUENCE_CONFLICT`,
+	STREAM_CLOSED: `STREAM_CLOSED`,
 	INVALID_OFFSET: `INVALID_OFFSET`,
 	UNEXPECTED_STATUS: `UNEXPECTED_STATUS`,
 	PARSE_ERROR: `PARSE_ERROR`,

package/dist/protocol.cjs

@@ -1,4 +1,4 @@
-const require_protocol = require('./protocol-IioVPNaP.cjs');
+const require_protocol = require('./protocol-sDk3deGa.cjs');
 
 exports.ErrorCodes = require_protocol.ErrorCodes
 exports.calculateStats = require_protocol.calculateStats

package/dist/protocol.d.cts

@@ -1,2 +1,2 @@
-import { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult } from "./protocol-BxZTqJmO.cjs";
-export { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult };
+import { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, CloseCommand, CloseResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, IdempotentCloseCommand, IdempotentCloseResult, IdempotentDetachCommand, IdempotentDetachResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, ServerCloseCommand, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult } from "./protocol-COHkkGmU.cjs";
+export { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, CloseCommand, CloseResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, IdempotentCloseCommand, IdempotentCloseResult, IdempotentDetachCommand, IdempotentDetachResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, ServerCloseCommand, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult };

package/dist/protocol.d.ts

@@ -1,2 +1,2 @@
-import { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes$1 as ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats$1 as calculateStats, decodeBase64$1 as decodeBase64, encodeBase64$1 as encodeBase64, formatStats$1 as formatStats, parseCommand$1 as parseCommand, parseResult$1 as parseResult, serializeCommand$1 as serializeCommand, serializeResult$1 as serializeResult } from "./protocol-JuFzdV5x.js";
-export { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult };
+import { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, CloseCommand, CloseResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes$1 as ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, IdempotentCloseCommand, IdempotentCloseResult, IdempotentDetachCommand, IdempotentDetachResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, ServerCloseCommand, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats$1 as calculateStats, decodeBase64$1 as decodeBase64, encodeBase64$1 as encodeBase64, formatStats$1 as formatStats, parseCommand$1 as parseCommand, parseResult$1 as parseResult, serializeCommand$1 as serializeCommand, serializeResult$1 as serializeResult } from "./protocol-9WN0gRRQ.js";
+export { AppendCommand, AppendResult, BenchmarkAppendOp, BenchmarkCommand, BenchmarkCreateOp, BenchmarkOperation, BenchmarkReadOp, BenchmarkResult, BenchmarkRoundtripOp, BenchmarkStats, BenchmarkThroughputAppendOp, BenchmarkThroughputReadOp, ClearDynamicCommand, ClearDynamicResult, CloseCommand, CloseResult, ConnectCommand, ConnectResult, CreateCommand, CreateResult, DeleteCommand, DeleteResult, ErrorCode, ErrorCodes, ErrorResult, HeadCommand, HeadResult, IdempotentAppendBatchCommand, IdempotentAppendBatchResult, IdempotentAppendCommand, IdempotentAppendResult, IdempotentCloseCommand, IdempotentCloseResult, IdempotentDetachCommand, IdempotentDetachResult, InitCommand, InitResult, ReadChunk, ReadCommand, ReadResult, ServerCloseCommand, SetDynamicHeaderCommand, SetDynamicHeaderResult, SetDynamicParamCommand, SetDynamicParamResult, ShutdownCommand, ShutdownResult, TestCommand, TestResult, ValidateCommand, ValidateIdempotentProducer, ValidateResult, ValidateRetryOptions, ValidateTarget, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult };

package/dist/protocol.js

@@ -1,3 +1,3 @@
-import { ErrorCodes, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult } from "./protocol-1p0soayz.js";
+import { ErrorCodes, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult } from "./protocol-BnqUAMKe.js";
 
 export { ErrorCodes, calculateStats, decodeBase64, encodeBase64, formatStats, parseCommand, parseResult, serializeCommand, serializeResult };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@durable-streams/client-conformance-tests",
   "description": "Conformance test suite for Durable Streams client implementations (producer and consumer)",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "author": "Durable Stream contributors",
   "bin": {
     "client-conformance-tests": "./dist/cli.js",
@@ -14,8 +14,8 @@
     "fast-check": "^4.4.0",
     "tsx": "^4.19.2",
     "yaml": "^2.7.1",
-    "@durable-streams/client": "0.2.0",
-    "@durable-streams/server": "0.1.7"
+    "@durable-streams/client": "0.2.1",
+    "@durable-streams/server": "0.2.1"
   },
   "devDependencies": {
     "tsdown": "^0.9.0",

package/src/adapters/typescript-adapter.ts

@@ -15,6 +15,7 @@ import {
   DurableStreamError,
   FetchError,
   IdempotentProducer,
+  StreamClosedError,
   stream,
 } from "@durable-streams/client"
 import {
@@ -40,6 +41,53 @@ let serverUrl = ``
 // Track content-type per stream path for append operations
 const streamContentTypes = new Map<string, string>()
 
+// Track IdempotentProducer instances to maintain state across operations
+// Key: "path|producerId|epoch"
+const producerCache = new Map<string, IdempotentProducer>()
+
+function getProducerCacheKey(
+  path: string,
+  producerId: string,
+  epoch: number
+): string {
+  return `${path}|${producerId}|${epoch}`
+}
+
+function getOrCreateProducer(
+  path: string,
+  producerId: string,
+  epoch: number,
+  autoClaim: boolean = false
+): IdempotentProducer {
+  const key = getProducerCacheKey(path, producerId, epoch)
+  let producer = producerCache.get(key)
+  if (!producer) {
+    const contentType =
+      streamContentTypes.get(path) ?? `application/octet-stream`
+    const ds = new DurableStream({
+      url: `${serverUrl}${path}`,
+      contentType,
+    })
+    producer = new IdempotentProducer(ds, producerId, {
+      epoch,
+      autoClaim,
+      maxInFlight: 1,
+      lingerMs: 0, // Send immediately for testing
+    })
+    producerCache.set(key, producer)
+  }
+  return producer
+}
+
+function removeProducerFromCache(
+  path: string,
+  producerId: string,
+  epoch: number
+): void {
+  const key = getProducerCacheKey(path, producerId, epoch)
+  producerCache.delete(key)
+}
+
 // Dynamic headers/params state
 interface DynamicValue {
   type: `counter` | `timestamp` | `token`
@@ -123,6 +171,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
       streamContentTypes.clear()
       dynamicHeaders.clear()
       dynamicParams.clear()
+      producerCache.clear()
       return {
         type: `init`,
         success: true,
@@ -160,6 +209,8 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
           ttlSeconds: command.ttlSeconds,
           expiresAt: command.expiresAt,
           headers: command.headers,
+          closed: command.closed,
+          body: command.data,
         })
 
         // Cache the content-type
@@ -326,6 +377,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
         const chunks: Array<ReadChunk> = []
         let finalOffset = command.offset ?? response.offset
         let upToDate = response.upToDate
+        let streamClosed = response.streamClosed
 
         // Collect chunks using body() for non-live mode or bodyStream() for live
         const maxChunks = command.maxChunks ?? 100
@@ -359,6 +411,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
           }
           finalOffset = response.offset
           upToDate = response.upToDate
+          streamClosed = response.streamClosed
         } else {
           // For live mode, use subscribeBytes which provides per-chunk metadata
           const decoder = new TextDecoder()
@@ -405,6 +458,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
 
               finalOffset = chunk.offset
               upToDate = chunk.upToDate
+              streamClosed = chunk.streamClosed
 
               // For waitForUpToDate, stop when we've reached up-to-date
               if (command.waitForUpToDate && chunk.upToDate) {
@@ -435,6 +489,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
                   // For empty streams, capture the final upToDate from response
                   upToDate = response.upToDate
                   finalOffset = response.offset
+                  streamClosed = response.streamClosed
                   resolve()
                 }
               })
@@ -463,6 +518,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
           chunks,
           offset: finalOffset,
           upToDate,
+          streamClosed,
           headersSent:
             Object.keys(headersSent).length > 0 ? headersSent : undefined,
           paramsSent:
@@ -492,6 +548,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
           status: 200,
           offset: result.offset,
           contentType: result.contentType,
+          streamClosed: result.streamClosed,
           // Note: HeadResult from client doesn't expose TTL info currently
         }
       } catch (err) {
@@ -520,6 +577,34 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
       }
     }
 
+    case `close`: {
+      try {
+        const url = `${serverUrl}${command.path}`
+
+        // Get content-type from cache or use default
+        const contentType =
+          streamContentTypes.get(command.path) ?? `application/octet-stream`
+
+        const ds = new DurableStream({
+          url,
+          contentType: command.contentType ?? contentType,
+        })
+
+        const closeResult = await ds.close({
+          body: command.data,
+          contentType: command.contentType,
+        })
+
+        return {
+          type: `close`,
+          success: true,
+          finalOffset: closeResult.finalOffset,
+        }
+      } catch (err) {
+        return errorResult(`close`, err)
+      }
+    }
+
     case `shutdown`: {
       return {
         type: `shutdown`,
@@ -565,39 +650,23 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
 
     case `idempotent-append`: {
       try {
-        const url = `${serverUrl}${command.path}`
-
-        // Get content-type from cache or use default
-        const contentType =
-          streamContentTypes.get(command.path) ?? `application/octet-stream`
-
-        const ds = new DurableStream({
-          url,
-          contentType,
-        })
-
-        const producer = new IdempotentProducer(ds, command.producerId, {
-          epoch: command.epoch,
-          autoClaim: command.autoClaim,
-          maxInFlight: 1,
-          lingerMs: 0, // Send immediately for testing
-        })
-
-        try {
-          // append() is fire-and-forget (synchronous), then flush() sends the batch
-          // Data is already pre-serialized, pass directly to append()
-          producer.append(command.data)
-          await producer.flush()
-          await producer.close()
+        const producer = getOrCreateProducer(
+          command.path,
+          command.producerId,
+          command.epoch,
+          command.autoClaim
+        )
+
+        // append() is fire-and-forget (synchronous), then flush() sends the batch
+        // Data is already pre-serialized, pass directly to append()
+        producer.append(command.data)
+        await producer.flush()
+        // Don't detach - keep producer for subsequent operations
 
-          return {
-            type: `idempotent-append`,
-            success: true,
-            status: 200,
-          }
-        } catch (err) {
-          await producer.close()
-          throw err
+        return {
+          type: `idempotent-append`,
+          success: true,
+          status: 200,
         }
       } catch (err) {
         return errorResult(`idempotent-append`, err)
@@ -640,7 +709,8 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
 
           // flush() sends the batch and waits for completion
           await producer.flush()
-          await producer.close()
+          // Use detach() to stop producer without closing the stream
+          await producer.detach()
 
           return {
             type: `idempotent-append-batch`,
@@ -648,7 +718,7 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
             status: 200,
           }
         } catch (err) {
-          await producer.close()
+          await producer.detach()
           throw err
         }
       } catch (err) {
@@ -656,6 +726,56 @@ async function handleCommand(command: TestCommand): Promise<TestResult> {
       }
     }
 
+    case `idempotent-close`: {
+      try {
+        const producer = getOrCreateProducer(
+          command.path,
+          command.producerId,
+          command.epoch,
+          command.autoClaim
+        )
+
+        // Close the stream with optional final message
+        const result = await producer.close(command.data)
+
+        // Keep producer in cache - subsequent close() calls should be idempotent
+        // The producer's internal #closed flag will handle idempotency
+
+        return {
+          type: `idempotent-close`,
+          success: true,
+          status: 200,
+          finalOffset: result.finalOffset,
+        }
+      } catch (err) {
+        return errorResult(`idempotent-close`, err)
+      }
+    }
+
+    case `idempotent-detach`: {
+      try {
+        const producer = getOrCreateProducer(
+          command.path,
+          command.producerId,
+          command.epoch
+        )
+
+        // Detach the producer without closing the stream
+        await producer.detach()
+
+        // Remove from cache since producer is detached
+        removeProducerFromCache(command.path, command.producerId, command.epoch)
+
+        return {
+          type: `idempotent-detach`,
+          success: true,
+          status: 200,
+        }
+      } catch (err) {
+        return errorResult(`idempotent-detach`, err)
+      }
+    }
+
     case `validate`: {
       // Test client-side input validation
       const { target } = command
@@ -728,6 +848,18 @@ function errorResult(
   commandType: TestCommand[`type`],
   err: unknown
 ): TestResult {
+  // Handle StreamClosedError specifically
+  if (err instanceof StreamClosedError) {
+    return {
+      type: `error`,
+      success: false,
+      commandType,
+      status: 409,
+      errorCode: ErrorCodes.STREAM_CLOSED,
+      message: err.message,
+    }
+  }
+
   if (err instanceof DurableStreamError) {
     let errorCode: ErrorCode = ErrorCodes.INTERNAL_ERROR
     let status: number | undefined
@@ -742,6 +874,9 @@ function errorResult(
     } else if (err.code === `CONFLICT_SEQ`) {
       errorCode = ErrorCodes.SEQUENCE_CONFLICT
       status = 409
+    } else if (err.code === `STREAM_CLOSED`) {
+      errorCode = ErrorCodes.STREAM_CLOSED
+      status = 409
     } else if (err.code === `BAD_REQUEST`) {
       errorCode = ErrorCodes.INVALID_OFFSET
       status = 400
@@ -766,8 +901,12 @@ function errorResult(
     if (err.status === 404) {
       errorCode = ErrorCodes.NOT_FOUND
     } else if (err.status === 409) {
-      // Check for sequence conflict vs general conflict
-      if (msg.includes(`sequence`)) {
+      // Check for stream closed header first
+      const streamClosedHeader =
+        err.headers[`stream-closed`] ?? err.headers[`Stream-Closed`]
+      if (streamClosedHeader?.toLowerCase() === `true`) {
+        errorCode = ErrorCodes.STREAM_CLOSED
+      } else if (msg.includes(`sequence`)) {
         errorCode = ErrorCodes.SEQUENCE_CONFLICT
       } else {
         errorCode = ErrorCodes.CONFLICT