@@ -93,6 +93,85 @@ describe("makeKeyedDrainableWorker", () => {
9393 ) ,
9494 ) ;
9595
96+ it . live ( "drains work offered during drain, including new keys and follow-ups" , ( ) =>
97+ Effect . scoped (
98+ Effect . gen ( function * ( ) {
99+ const processed : string [ ] = [ ] ;
100+ const a1Started = yield * Deferred . make < void > ( ) ;
101+ const releaseA1 = yield * Deferred . make < void > ( ) ;
102+ const b1Started = yield * Deferred . make < void > ( ) ;
103+ const releaseB1 = yield * Deferred . make < void > ( ) ;
104+ const c1Started = yield * Deferred . make < void > ( ) ;
105+ const releaseC1 = yield * Deferred . make < void > ( ) ;
106+ const worker = yield * makeKeyedDrainableWorker (
107+ ( item : { readonly key : string ; readonly value : string } ) => item . key ,
108+ ( item ) =>
109+ Effect . gen ( function * ( ) {
110+ if ( item . value === "a1" ) {
111+ yield * Deferred . succeed ( a1Started , undefined ) ;
112+ yield * Deferred . await ( releaseA1 ) ;
113+ }
114+ if ( item . value === "b1" ) {
115+ yield * Deferred . succeed ( b1Started , undefined ) ;
116+ yield * Deferred . await ( releaseB1 ) ;
117+ }
118+ if ( item . value === "c1" ) {
119+ yield * Deferred . succeed ( c1Started , undefined ) ;
120+ yield * Deferred . await ( releaseC1 ) ;
121+ }
122+ processed . push ( item . value ) ;
123+ } ) ,
124+ ) ;
125+
126+ yield * worker . enqueue ( { key : "a" , value : "a1" } ) ;
127+ yield * worker . enqueue ( { key : "b" , value : "b1" } ) ;
128+ yield * Deferred . await ( a1Started ) ;
129+ yield * Deferred . await ( b1Started ) ;
130+
131+ const drained = yield * Deferred . make < void > ( ) ;
132+ yield * Effect . forkChild (
133+ worker . drain . pipe (
134+ Effect . tap ( ( ) => Deferred . succeed ( drained , undefined ) . pipe ( Effect . orDie ) ) ,
135+ ) ,
136+ ) ;
137+
138+ // Let the forked drain snapshot lanes [a, b]: no other work can be
139+ // enqueued while this fiber only yields, so after ample scheduler
140+ // turns the drain is parked waiting on the blocked a1/b1 lanes.
141+ // (Scheduler turns only — no wall-clock.)
142+ for ( let i = 0 ; i < 50 ; i ++ ) {
143+ yield * Effect . yieldNow ;
144+ }
145+
146+ // Offer a follow-up on existing lane "a" (a1 still blocked, so the
147+ // lane entry is stable and cannot be cleaned up mid-race) plus a
148+ // brand-new blocked key "c" — both strictly after the snapshot.
149+ // A snapshot-only drain never waits on "c", so it settles once
150+ // a/b release while c1 is still pending.
151+ yield * worker . enqueue ( { key : "a" , value : "a2" } ) ;
152+ yield * worker . enqueue ( { key : "c" , value : "c1" } ) ;
153+ yield * Deferred . await ( c1Started ) ;
154+ expect ( yield * Deferred . isDone ( drained ) ) . toBe ( false ) ;
155+
156+ // Releasing a/b must not settle the drain while c1 is pending.
157+ yield * Deferred . succeed ( releaseA1 , undefined ) ;
158+ yield * Deferred . succeed ( releaseB1 , undefined ) ;
159+ // Give the drain ample scheduler turns to (incorrectly) settle: the
160+ // quiescent drain stays pending regardless of turns taken since c1
161+ // is still blocked.
162+ for ( let i = 0 ; i < 50 ; i ++ ) {
163+ yield * Effect . yieldNow ;
164+ }
165+ expect ( processed ) . not . toContain ( "c1" ) ;
166+ expect ( yield * Deferred . isDone ( drained ) ) . toBe ( false ) ;
167+
168+ yield * Deferred . succeed ( releaseC1 , undefined ) ;
169+ yield * Deferred . await ( drained ) ;
170+ expect ( processed . toSorted ( ) ) . toEqual ( [ "a1" , "a2" , "b1" , "c1" ] ) ;
171+ } ) ,
172+ ) ,
173+ ) ;
174+
96175 it . live ( "creates a single lane under concurrent same-key enqueues" , ( ) =>
97176 Effect . scoped (
98177 Effect . gen ( function * ( ) {
0 commit comments