@@ -294,6 +294,111 @@ describe("thread outbox", () => {
294294 registry . dispose ( ) ;
295295 } ) ;
296296
297+ it ( "publishes an enqueued message before the durable write resolves" , async ( ) => {
298+ const registry = AtomRegistry . make ( ) ;
299+ let releaseWrite ! : ( ) => void ;
300+ const writeBlocked = new Promise < void > ( ( resolve ) => {
301+ releaseWrite = resolve ;
302+ } ) ;
303+ const manager = createThreadOutboxManager ( {
304+ registry,
305+ storage : {
306+ load : async ( ) => [ ] ,
307+ write : async ( ) => writeBlocked ,
308+ remove : async ( ) => undefined ,
309+ } ,
310+ } ) ;
311+ const message = queuedMessage ( {
312+ messageId : "message-1" ,
313+ createdAt : "2026-06-08T10:00:01.000Z" ,
314+ } ) ;
315+
316+ const enqueueing = manager . enqueue ( message ) ;
317+ expect ( registry . get ( manager . queuedMessagesByThreadKeyAtom ) ) . toEqual ( {
318+ "environment-1:thread-1" : [ message ] ,
319+ } ) ;
320+
321+ releaseWrite ( ) ;
322+ await enqueueing ;
323+ expect ( registry . get ( manager . queuedMessagesByThreadKeyAtom ) ) . toEqual ( {
324+ "environment-1:thread-1" : [ message ] ,
325+ } ) ;
326+ registry . dispose ( ) ;
327+ } ) ;
328+
329+ it ( "rolls an enqueued message back out when the durable write fails" , async ( ) => {
330+ const registry = AtomRegistry . make ( ) ;
331+ const writeCause = new Error ( "disk full" ) ;
332+ const manager = createThreadOutboxManager ( {
333+ registry,
334+ storage : {
335+ load : async ( ) => [ ] ,
336+ write : async ( ) => {
337+ throw writeCause ;
338+ } ,
339+ remove : async ( ) => undefined ,
340+ } ,
341+ } ) ;
342+ const message = queuedMessage ( {
343+ messageId : "message-1" ,
344+ createdAt : "2026-06-08T10:00:01.000Z" ,
345+ } ) ;
346+
347+ await expect ( manager . enqueue ( message ) ) . rejects . toEqual (
348+ new ThreadOutboxManagerError ( {
349+ operation : "enqueue" ,
350+ environmentId : message . environmentId ,
351+ threadId : message . threadId ,
352+ messageId : message . messageId ,
353+ cause : writeCause ,
354+ } ) ,
355+ ) ;
356+ expect ( registry . get ( manager . queuedMessagesByThreadKeyAtom ) ) . toEqual ( { } ) ;
357+ registry . dispose ( ) ;
358+ } ) ;
359+
360+ it ( "keeps a same-id retry queued when the first attempt's write fails" , async ( ) => {
361+ const registry = AtomRegistry . make ( ) ;
362+ let failNextWrite = true ;
363+ let releaseFirstWrite ! : ( ) => void ;
364+ const firstWriteBlocked = new Promise < void > ( ( resolve ) => {
365+ releaseFirstWrite = resolve ;
366+ } ) ;
367+ const manager = createThreadOutboxManager ( {
368+ registry,
369+ storage : {
370+ load : async ( ) => [ ] ,
371+ write : async ( ) => {
372+ if ( failNextWrite ) {
373+ failNextWrite = false ;
374+ await firstWriteBlocked ;
375+ throw new Error ( "disk full" ) ;
376+ }
377+ } ,
378+ remove : async ( ) => undefined ,
379+ } ,
380+ } ) ;
381+ const message = queuedMessage ( {
382+ messageId : "message-1" ,
383+ createdAt : "2026-06-08T10:00:01.000Z" ,
384+ } ) ;
385+ const retried = { ...message , text : "retried" } ;
386+
387+ const first = manager . enqueue ( message ) ;
388+ const second = manager . enqueue ( retried ) ;
389+ releaseFirstWrite ( ) ;
390+ await expect ( first ) . rejects . toBeInstanceOf ( ThreadOutboxManagerError ) ;
391+ await second ;
392+
393+ // The failed first attempt must not roll back the retry that replaced it.
394+ expect ( registry . get ( manager . queuedMessagesByThreadKeyAtom ) ) . toEqual ( {
395+ "environment-1:thread-1" : [ retried ] ,
396+ } ) ;
397+ await expect ( manager . confirmQueued ( retried ) ) . resolves . toBe ( true ) ;
398+ await expect ( manager . confirmQueued ( message ) ) . resolves . toBe ( false ) ;
399+ registry . dispose ( ) ;
400+ } ) ;
401+
297402 it ( "replaces an existing message when an enqueue retry uses the same id" , async ( ) => {
298403 const registry = AtomRegistry . make ( ) ;
299404 const manager = createThreadOutboxManager ( {
0 commit comments