@durable-streams/server 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -430,9 +430,9 @@ var StreamStore = class {
 				epoch: options.producerEpoch,
 				seq: options.producerSeq
 			};
-			this.notifyLongPollsClosed(path);
 		}
 		this.notifyLongPolls(path);
+		if (options.close) this.notifyLongPollsClosed(path);
 		if (producerResult || options.close) return {
 			message,
 			producerResult,
@@ -984,6 +984,13 @@ var FileBackedStreamStore = class {
 	* Key: "{streamPath}:{producerId}"
 	*/
 	producerLocks = new Map();
+	/**
+	* Per-stream append locks. Serializes the read-modify-write of currentOffset
+	* across all concurrent appenders on the same stream so the LMDB-tracked
+	* offset cannot drift behind the file's actual byte position.
+	* Key: streamPath
+	*/
+	streamAppendLocks = new Map();
 	constructor(options) {
 		this.dataDir = options.dataDir;
 		this.db = (0, lmdb.open)({
@@ -1180,6 +1187,26 @@ var FileBackedStreamStore = class {
 		};
 	}
 	/**
+	* Acquire a per-stream append lock that serializes the read-modify-write
+	* of currentOffset across all concurrent appenders on the same stream.
+	* Without this, two concurrent appends can read the same starting
+	* currentOffset, both compute their newOffset, both write a frame to the
+	* file, but only one of their LMDB updates wins — leaving currentOffset
+	* lagging the file's actual byte position. Returns a release function.
+	*/
+	async acquireStreamAppendLock(streamPath) {
+		while (this.streamAppendLocks.has(streamPath)) await this.streamAppendLocks.get(streamPath);
+		let releaseLock;
+		const lockPromise = new Promise((resolve) => {
+			releaseLock = resolve;
+		});
+		this.streamAppendLocks.set(streamPath, lockPromise);
+		return () => {
+			this.streamAppendLocks.delete(streamPath);
+			releaseLock();
+		};
+	}
+	/**
 	* Get the current epoch for a producer on a stream.
 	* Returns undefined if the producer doesn't exist or stream not found.
 	*/
@@ -1437,7 +1464,20 @@ var FileBackedStreamStore = class {
 			}
 		}
 	}
+	/**
+	* Public append entry point. Serializes concurrent appends to the same
+	* stream so the read-modify-write of currentOffset cannot interleave —
+	* see acquireStreamAppendLock for the underlying race.
+	*/
 	async append(streamPath, data, options = {}) {
+		const releaseLock = await this.acquireStreamAppendLock(streamPath);
+		try {
+			return await this.appendInner(streamPath, data, options);
+		} finally {
+			releaseLock();
+		}
+	}
+	async appendInner(streamPath, data, options = {}) {
 		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
 		if (streamMeta.softDeleted) throw new Error(`Stream is soft-deleted: ${streamPath}`);
@@ -2282,13 +2322,13 @@ var DurableStreamTestServer = class {
 	*/
 	async handleCreate(path, req, res) {
 		let contentType = req.headers[`content-type`];
-		if (!contentType || contentType.trim() === `` || !/^[\w-]+\/[\w-]+/.test(contentType)) contentType = `application/octet-stream`;
+		const forkedFromHeader = req.headers[STREAM_FORKED_FROM_HEADER.toLowerCase()];
+		const forkOffsetHeader = req.headers[STREAM_FORK_OFFSET_HEADER.toLowerCase()];
+		if (!contentType || contentType.trim() === `` || !/^[\w-]+\/[\w-]+/.test(contentType)) contentType = forkedFromHeader ? void 0 : `application/octet-stream`;
 		const ttlHeader = req.headers[STREAM_TTL_HEADER.toLowerCase()];
 		const expiresAtHeader = req.headers[STREAM_EXPIRES_AT_HEADER.toLowerCase()];
 		const closedHeader = req.headers[STREAM_CLOSED_HEADER.toLowerCase()];
 		const createClosed = closedHeader === `true`;
-		const forkedFromHeader = req.headers[STREAM_FORKED_FROM_HEADER.toLowerCase()];
-		const forkOffsetHeader = req.headers[STREAM_FORK_OFFSET_HEADER.toLowerCase()];
 		if (ttlHeader && expiresAtHeader) {
 			res.writeHead(400, { "content-type": `text/plain` });
 			res.end(`Cannot specify both Stream-TTL and Stream-Expires-At`);
@@ -2363,14 +2403,15 @@ var DurableStreamTestServer = class {
 			throw err;
 		}
 		const stream = this.store.get(path);
+		const resolvedContentType = stream.contentType ?? contentType ?? `application/octet-stream`;
 		if (isNew && this.options.onStreamCreated) await Promise.resolve(this.options.onStreamCreated({
 			type: `created`,
 			path,
-			contentType: stream.contentType ?? contentType,
+			contentType: resolvedContentType,
 			timestamp: Date.now()
 		}));
 		const headers = {
-			"content-type": stream.contentType ?? contentType,
+			"content-type": resolvedContentType,
 			[STREAM_OFFSET_HEADER]: stream.currentOffset
 		};
 		if (isNew) headers[`location`] = `${this._url}${path}`;
@@ -2621,7 +2662,7 @@ var DurableStreamTestServer = class {
 				const result = await this.store.waitForMessages(path, currentOffset, this.options.longPollTimeout);
 				this.store.touchAccess(path);
 				if (this.isShuttingDown || !isConnected) break;
-				if (result.streamClosed) {
+				if (result.streamClosed && result.messages.length === 0) {
 					const finalControlData = {
 						[SSE_OFFSET_FIELD]: currentOffset,
 						[SSE_CLOSED_FIELD]: true

package/dist/index.d.cts

@@ -475,6 +475,13 @@ declare class FileBackedStreamStore {
   * Key: "{streamPath}:{producerId}"
   */
   private producerLocks;
+  /**
+  * Per-stream append locks. Serializes the read-modify-write of currentOffset
+  * across all concurrent appenders on the same stream so the LMDB-tracked
+  * offset cannot drift behind the file's actual byte position.
+  * Key: streamPath
+  */
+  private streamAppendLocks;
   constructor(options: FileBackedStreamStoreOptions);
   /**
   * Recover streams from disk on startup.
@@ -505,6 +512,15 @@ declare class FileBackedStreamStore {
   */
   private acquireProducerLock;
   /**
+  * Acquire a per-stream append lock that serializes the read-modify-write
+  * of currentOffset across all concurrent appenders on the same stream.
+  * Without this, two concurrent appends can read the same starting
+  * currentOffset, both compute their newOffset, both write a frame to the
+  * file, but only one of their LMDB updates wins — leaving currentOffset
+  * lagging the file's actual byte position. Returns a release function.
+  */
+  private acquireStreamAppendLock;
+  /**
   * Get the current epoch for a producer on a stream.
   * Returns undefined if the producer doesn't exist or stream not found.
   */
@@ -550,9 +566,15 @@ declare class FileBackedStreamStore {
   * whose refcount drops to zero.
   */
   private deleteWithCascade;
+  /**
+  * Public append entry point. Serializes concurrent appends to the same
+  * stream so the read-modify-write of currentOffset cannot interleave —
+  * see acquireStreamAppendLock for the underlying race.
+  */
   append(streamPath: string, data: Uint8Array, options?: AppendOptions & {
     isInitialCreate?: boolean;
   }): Promise<StreamMessage | AppendResult | null>;
+  private appendInner;
   /**
   * Append with producer serialization for concurrent request handling.
   * This ensures that validation+append is atomic per producer.

package/dist/index.d.ts

@@ -475,6 +475,13 @@ declare class FileBackedStreamStore {
   * Key: "{streamPath}:{producerId}"
   */
   private producerLocks;
+  /**
+  * Per-stream append locks. Serializes the read-modify-write of currentOffset
+  * across all concurrent appenders on the same stream so the LMDB-tracked
+  * offset cannot drift behind the file's actual byte position.
+  * Key: streamPath
+  */
+  private streamAppendLocks;
   constructor(options: FileBackedStreamStoreOptions);
   /**
   * Recover streams from disk on startup.
@@ -505,6 +512,15 @@ declare class FileBackedStreamStore {
   */
   private acquireProducerLock;
   /**
+  * Acquire a per-stream append lock that serializes the read-modify-write
+  * of currentOffset across all concurrent appenders on the same stream.
+  * Without this, two concurrent appends can read the same starting
+  * currentOffset, both compute their newOffset, both write a frame to the
+  * file, but only one of their LMDB updates wins — leaving currentOffset
+  * lagging the file's actual byte position. Returns a release function.
+  */
+  private acquireStreamAppendLock;
+  /**
   * Get the current epoch for a producer on a stream.
   * Returns undefined if the producer doesn't exist or stream not found.
   */
@@ -550,9 +566,15 @@ declare class FileBackedStreamStore {
   * whose refcount drops to zero.
   */
   private deleteWithCascade;
+  /**
+  * Public append entry point. Serializes concurrent appends to the same
+  * stream so the read-modify-write of currentOffset cannot interleave —
+  * see acquireStreamAppendLock for the underlying race.
+  */
   append(streamPath: string, data: Uint8Array, options?: AppendOptions & {
     isInitialCreate?: boolean;
   }): Promise<StreamMessage | AppendResult | null>;
+  private appendInner;
   /**
   * Append with producer serialization for concurrent request handling.
   * This ensures that validation+append is atomic per producer.

package/dist/index.js

@@ -407,9 +407,9 @@ var StreamStore = class {
 				epoch: options.producerEpoch,
 				seq: options.producerSeq
 			};
-			this.notifyLongPollsClosed(path$2);
 		}
 		this.notifyLongPolls(path$2);
+		if (options.close) this.notifyLongPollsClosed(path$2);
 		if (producerResult || options.close) return {
 			message,
 			producerResult,
@@ -961,6 +961,13 @@ var FileBackedStreamStore = class {
 	* Key: "{streamPath}:{producerId}"
 	*/
 	producerLocks = new Map();
+	/**
+	* Per-stream append locks. Serializes the read-modify-write of currentOffset
+	* across all concurrent appenders on the same stream so the LMDB-tracked
+	* offset cannot drift behind the file's actual byte position.
+	* Key: streamPath
+	*/
+	streamAppendLocks = new Map();
 	constructor(options) {
 		this.dataDir = options.dataDir;
 		this.db = open({
@@ -1157,6 +1164,26 @@ var FileBackedStreamStore = class {
 		};
 	}
 	/**
+	* Acquire a per-stream append lock that serializes the read-modify-write
+	* of currentOffset across all concurrent appenders on the same stream.
+	* Without this, two concurrent appends can read the same starting
+	* currentOffset, both compute their newOffset, both write a frame to the
+	* file, but only one of their LMDB updates wins — leaving currentOffset
+	* lagging the file's actual byte position. Returns a release function.
+	*/
+	async acquireStreamAppendLock(streamPath) {
+		while (this.streamAppendLocks.has(streamPath)) await this.streamAppendLocks.get(streamPath);
+		let releaseLock;
+		const lockPromise = new Promise((resolve) => {
+			releaseLock = resolve;
+		});
+		this.streamAppendLocks.set(streamPath, lockPromise);
+		return () => {
+			this.streamAppendLocks.delete(streamPath);
+			releaseLock();
+		};
+	}
+	/**
 	* Get the current epoch for a producer on a stream.
 	* Returns undefined if the producer doesn't exist or stream not found.
 	*/
@@ -1414,7 +1441,20 @@ var FileBackedStreamStore = class {
 			}
 		}
 	}
+	/**
+	* Public append entry point. Serializes concurrent appends to the same
+	* stream so the read-modify-write of currentOffset cannot interleave —
+	* see acquireStreamAppendLock for the underlying race.
+	*/
 	async append(streamPath, data, options = {}) {
+		const releaseLock = await this.acquireStreamAppendLock(streamPath);
+		try {
+			return await this.appendInner(streamPath, data, options);
+		} finally {
+			releaseLock();
+		}
+	}
+	async appendInner(streamPath, data, options = {}) {
 		const streamMeta = this.getMetaIfNotExpired(streamPath);
 		if (!streamMeta) throw new Error(`Stream not found: ${streamPath}`);
 		if (streamMeta.softDeleted) throw new Error(`Stream is soft-deleted: ${streamPath}`);
@@ -2259,13 +2299,13 @@ var DurableStreamTestServer = class {
 	*/
 	async handleCreate(path$2, req, res) {
 		let contentType = req.headers[`content-type`];
-		if (!contentType || contentType.trim() === `` || !/^[\w-]+\/[\w-]+/.test(contentType)) contentType = `application/octet-stream`;
+		const forkedFromHeader = req.headers[STREAM_FORKED_FROM_HEADER.toLowerCase()];
+		const forkOffsetHeader = req.headers[STREAM_FORK_OFFSET_HEADER.toLowerCase()];
+		if (!contentType || contentType.trim() === `` || !/^[\w-]+\/[\w-]+/.test(contentType)) contentType = forkedFromHeader ? void 0 : `application/octet-stream`;
 		const ttlHeader = req.headers[STREAM_TTL_HEADER.toLowerCase()];
 		const expiresAtHeader = req.headers[STREAM_EXPIRES_AT_HEADER.toLowerCase()];
 		const closedHeader = req.headers[STREAM_CLOSED_HEADER.toLowerCase()];
 		const createClosed = closedHeader === `true`;
-		const forkedFromHeader = req.headers[STREAM_FORKED_FROM_HEADER.toLowerCase()];
-		const forkOffsetHeader = req.headers[STREAM_FORK_OFFSET_HEADER.toLowerCase()];
 		if (ttlHeader && expiresAtHeader) {
 			res.writeHead(400, { "content-type": `text/plain` });
 			res.end(`Cannot specify both Stream-TTL and Stream-Expires-At`);
@@ -2340,14 +2380,15 @@ var DurableStreamTestServer = class {
 			throw err;
 		}
 		const stream = this.store.get(path$2);
+		const resolvedContentType = stream.contentType ?? contentType ?? `application/octet-stream`;
 		if (isNew && this.options.onStreamCreated) await Promise.resolve(this.options.onStreamCreated({
 			type: `created`,
 			path: path$2,
-			contentType: stream.contentType ?? contentType,
+			contentType: resolvedContentType,
 			timestamp: Date.now()
 		}));
 		const headers = {
-			"content-type": stream.contentType ?? contentType,
+			"content-type": resolvedContentType,
 			[STREAM_OFFSET_HEADER]: stream.currentOffset
 		};
 		if (isNew) headers[`location`] = `${this._url}${path$2}`;
@@ -2598,7 +2639,7 @@ var DurableStreamTestServer = class {
 				const result = await this.store.waitForMessages(path$2, currentOffset, this.options.longPollTimeout);
 				this.store.touchAccess(path$2);
 				if (this.isShuttingDown || !isConnected) break;
-				if (result.streamClosed) {
+				if (result.streamClosed && result.messages.length === 0) {
 					const finalControlData = {
 						[SSE_OFFSET_FIELD]: currentOffset,
 						[SSE_CLOSED_FIELD]: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@durable-streams/server",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Node.js reference server implementation for Durable Streams",
   "author": "Durable Stream contributors",
   "license": "Apache-2.0",
@@ -39,15 +39,15 @@
   "dependencies": {
     "@neophi/sieve-cache": "^1.0.0",
     "lmdb": "^3.3.0",
-    "@durable-streams/client": "0.2.3",
-    "@durable-streams/state": "0.2.4"
+    "@durable-streams/client": "0.2.4",
+    "@durable-streams/state": "0.2.6"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsdown": "^0.9.0",
     "typescript": "^5.0.0",
     "vitest": "^4.0.0",
-    "@durable-streams/server-conformance-tests": "0.3.0"
+    "@durable-streams/server-conformance-tests": "0.3.1"
   },
   "files": [
     "dist",

package/src/file-store.ts

@@ -232,6 +232,13 @@ export class FileBackedStreamStore {
    * Key: "{streamPath}:{producerId}"
    */
   private producerLocks = new Map<string, Promise<unknown>>()
+  /**
+   * Per-stream append locks. Serializes the read-modify-write of currentOffset
+   * across all concurrent appenders on the same stream so the LMDB-tracked
+   * offset cannot drift behind the file's actual byte position.
+   * Key: streamPath
+   */
+  private streamAppendLocks = new Map<string, Promise<unknown>>()
 
   constructor(options: FileBackedStreamStoreOptions) {
     this.dataDir = options.dataDir
@@ -535,6 +542,33 @@ export class FileBackedStreamStore {
     }
   }
 
+  /**
+   * Acquire a per-stream append lock that serializes the read-modify-write
+   * of currentOffset across all concurrent appenders on the same stream.
+   * Without this, two concurrent appends can read the same starting
+   * currentOffset, both compute their newOffset, both write a frame to the
+   * file, but only one of their LMDB updates wins — leaving currentOffset
+   * lagging the file's actual byte position. Returns a release function.
+   */
+  private async acquireStreamAppendLock(
+    streamPath: string
+  ): Promise<() => void> {
+    while (this.streamAppendLocks.has(streamPath)) {
+      await this.streamAppendLocks.get(streamPath)
+    }
+
+    let releaseLock: () => void
+    const lockPromise = new Promise<void>((resolve) => {
+      releaseLock = resolve
+    })
+    this.streamAppendLocks.set(streamPath, lockPromise)
+
+    return () => {
+      this.streamAppendLocks.delete(streamPath)
+      releaseLock!()
+    }
+  }
+
   /**
    * Get the current epoch for a producer on a stream.
    * Returns undefined if the producer doesn't exist or stream not found.
@@ -985,10 +1019,28 @@ export class FileBackedStreamStore {
     }
   }
 
+  /**
+   * Public append entry point. Serializes concurrent appends to the same
+   * stream so the read-modify-write of currentOffset cannot interleave —
+   * see acquireStreamAppendLock for the underlying race.
+   */
   async append(
     streamPath: string,
     data: Uint8Array,
     options: AppendOptions & { isInitialCreate?: boolean } = {}
+  ): Promise<StreamMessage | AppendResult | null> {
+    const releaseLock = await this.acquireStreamAppendLock(streamPath)
+    try {
+      return await this.appendInner(streamPath, data, options)
+    } finally {
+      releaseLock()
+    }
+  }
+
+  private async appendInner(
+    streamPath: string,
+    data: Uint8Array,
+    options: AppendOptions & { isInitialCreate?: boolean } = {}
   ): Promise<StreamMessage | AppendResult | null> {
     const streamMeta = this.getMetaIfNotExpired(streamPath)
 

package/src/server.ts

@@ -562,13 +562,24 @@ export class DurableStreamTestServer {
   ): Promise<void> {
     let contentType = req.headers[`content-type`]
 
-    // Sanitize content-type: if empty or invalid, use default
+    // Parse fork headers (must come before content-type sanitization so
+    // forks can fall through to the store's content-type inheritance)
+    const forkedFromHeader = req.headers[
+      STREAM_FORKED_FROM_HEADER.toLowerCase()
+    ] as string | undefined
+    const forkOffsetHeader = req.headers[
+      STREAM_FORK_OFFSET_HEADER.toLowerCase()
+    ] as string | undefined
+
+    // Sanitize content-type: if empty or invalid, use default — but only
+    // for non-fork creates. For forks, an omitted Content-Type means "inherit
+    // from source", which is resolved by the store.
     if (
       !contentType ||
       contentType.trim() === `` ||
       !/^[\w-]+\/[\w-]+/.test(contentType)
     ) {
-      contentType = `application/octet-stream`
+      contentType = forkedFromHeader ? undefined : `application/octet-stream`
     }
 
     const ttlHeader = req.headers[STREAM_TTL_HEADER.toLowerCase()] as
@@ -582,14 +593,6 @@ export class DurableStreamTestServer {
     const closedHeader = req.headers[STREAM_CLOSED_HEADER.toLowerCase()]
     const createClosed = closedHeader === `true`
 
-    // Parse fork headers
-    const forkedFromHeader = req.headers[
-      STREAM_FORKED_FROM_HEADER.toLowerCase()
-    ] as string | undefined
-    const forkOffsetHeader = req.headers[
-      STREAM_FORK_OFFSET_HEADER.toLowerCase()
-    ] as string | undefined
-
     // Validate TTL and Expires-At headers
     if (ttlHeader && expiresAtHeader) {
       res.writeHead(400, { "content-type": `text/plain` })
@@ -681,6 +684,8 @@ export class DurableStreamTestServer {
     }
 
     const stream = this.store.get(path)!
+    const resolvedContentType =
+      stream.contentType ?? contentType ?? `application/octet-stream`
 
     // Call lifecycle hook for new streams
     if (isNew && this.options.onStreamCreated) {
@@ -688,7 +693,7 @@ export class DurableStreamTestServer {
         this.options.onStreamCreated({
           type: `created`,
           path,
-          contentType: stream.contentType ?? contentType,
+          contentType: resolvedContentType,
           timestamp: Date.now(),
         })
       )
@@ -696,7 +701,7 @@ export class DurableStreamTestServer {
 
     // Return 201 for new streams, 200 for idempotent creates
     const headers: Record<string, string> = {
-      "content-type": stream.contentType ?? contentType,
+      "content-type": resolvedContentType,
       [STREAM_OFFSET_HEADER]: stream.currentOffset,
     }
 
@@ -1182,8 +1187,10 @@ export class DurableStreamTestServer {
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (this.isShuttingDown || !isConnected) break
 
-        // Check if stream was closed during wait
-        if (result.streamClosed) {
+        // Check if stream was closed during wait. If the close also appended
+        // final data, let the next loop iteration deliver those messages
+        // before emitting the streamClosed control event.
+        if (result.streamClosed && result.messages.length === 0) {
           const finalControlData: Record<string, string | boolean> = {
             [SSE_OFFSET_FIELD]: currentOffset,
             [SSE_CLOSED_FIELD]: true,

package/src/store.ts

@@ -723,13 +723,17 @@ export class StreamStore {
           seq: options.producerSeq!,
         }
       }
-      // Notify pending long-polls that stream is closed
-      this.notifyLongPollsClosed(path)
     }
 
-    // Notify any pending long-polls of new messages
+    // Notify pending long-polls of new messages before empty close signals.
+    // Append-and-close must deliver the final message with streamClosed
+    // metadata instead of waking readers with an empty close event first.
     this.notifyLongPolls(path)
 
+    if (options.close) {
+      this.notifyLongPollsClosed(path)
+    }
+
     // Return AppendResult if producer headers were used or stream was closed
     if (producerResult || options.close) {
       return {