@@ -734,6 +734,92 @@ it.layer(
734734 } ) ,
735735 ) ;
736736
737+ it . effect ( "releases delivered output while the process queue stays busy" , ( ) =>
738+ Effect . gen ( function * ( ) {
739+ // Observe retained payloads, since delivery and bounded history alone cannot detect a leak.
740+ let readState : Effect . Effect < unknown > = Effect . void ;
741+ const makeRef = vi . mocked ( SynchronizedRef . make ) . getMockImplementation ( ) ! ;
742+ using _capture = vi . spyOn ( SynchronizedRef , "make" ) . mockImplementation ( < A > ( value : A ) =>
743+ makeRef ( value ) . pipe (
744+ Effect . tap ( ( ref ) =>
745+ Effect . sync ( ( ) => {
746+ if ( typeof value === "object" && value !== null && "sessions" in value ) {
747+ readState = SynchronizedRef . get ( ref ) ;
748+ }
749+ } ) ,
750+ ) ,
751+ ) ,
752+ ) ;
753+ const { manager, ptyAdapter } = yield * createManager ( 5 , { historyByteLimit : 1024 } ) ;
754+ yield * manager . open ( openInput ( ) ) ;
755+ const process = ptyAdapter . processes [ 0 ] ! ;
756+ const entered = yield * Deferred . make < void > ( ) ;
757+ const release = yield * Deferred . make < void > ( ) ;
758+ const measured = yield * Deferred . make < void > ( ) ;
759+ const finish = yield * Deferred . make < void > ( ) ;
760+ const drained = yield * Deferred . make < void > ( ) ;
761+ yield * Effect . addFinalizer ( ( ) => Deferred . succeed ( finish , undefined ) ) ;
762+ yield * Effect . addFinalizer ( ( ) => Deferred . succeed ( release , undefined ) ) ;
763+ const chunkBytes = 64 * 1024 ;
764+ const chunkCount = 256 ;
765+ let delivered = 0 ;
766+ const unsubscribe = yield * manager . subscribe ( ( event ) =>
767+ Effect . gen ( function * ( ) {
768+ if ( event . type !== "output" ) return ;
769+ delivered += 1 ;
770+ expect ( event . data ) . toBe (
771+ delivered === 1
772+ ? "start"
773+ : ( delivered === 2
774+ ? "queued-a"
775+ : delivered === 3
776+ ? "queued-b"
777+ : `${ delivered - 3 } `
778+ ) . padEnd ( chunkBytes , "x" ) ,
779+ ) ;
780+ if ( delivered === 1 ) {
781+ yield * Deferred . succeed ( entered , undefined ) ;
782+ yield * Deferred . await ( release ) ;
783+ }
784+ if ( delivered === chunkCount ) {
785+ yield * Deferred . succeed ( measured , undefined ) ;
786+ yield * Deferred . await ( finish ) ;
787+ } else if ( delivered < chunkCount ) {
788+ process . emitData ( `${ delivered } ` . padEnd ( chunkBytes , "x" ) ) ;
789+ } else if ( delivered === chunkCount + 2 ) {
790+ yield * Deferred . succeed ( drained , undefined ) ;
791+ }
792+ } ) ,
793+ ) ;
794+ yield * Effect . addFinalizer ( ( ) => Effect . sync ( unsubscribe ) ) ;
795+ process . emitData ( "start" ) ;
796+ yield * Deferred . await ( entered ) ;
797+ process . emitData ( "queued-a" . padEnd ( chunkBytes , "x" ) ) ;
798+ process . emitData ( "queued-b" . padEnd ( chunkBytes , "x" ) ) ;
799+ yield * Deferred . succeed ( release , undefined ) ;
800+ yield * Deferred . await ( measured ) ;
801+
802+ const state = ( yield * readState ) as {
803+ sessions : ReadonlyMap <
804+ string ,
805+ { pendingProcessEvents : ReadonlyArray < { data ?: string } | undefined > }
806+ > ;
807+ } ;
808+ const retained = [ ...state . sessions . values ( ) ] . flatMap (
809+ ( session ) => session . pendingProcessEvents ,
810+ ) ;
811+ const retainedBytes = retained . reduce (
812+ ( bytes , event ) => bytes + ( event ?. data ?. length ?? 0 ) ,
813+ 0 ,
814+ ) ;
815+ expect ( delivered ) . toBe ( chunkCount ) ;
816+ expect ( retainedBytes ) . toBeLessThanOrEqual ( 2 * chunkBytes ) ;
817+ expect ( retained . length ) . toBeLessThanOrEqual ( 4 ) ;
818+ yield * Deferred . succeed ( finish , undefined ) ;
819+ yield * Deferred . await ( drained ) ;
820+ } ) ,
821+ ) ;
822+
737823 it . effect ( "retains plain Unicode and control characters around a split query" , ( ) =>
738824 Effect . gen ( function * ( ) {
739825 const { manager, ptyAdapter } = yield * createManager ( ) ;
0 commit comments