@@ -995,6 +995,92 @@ it.layer(
995995 } ) ,
996996 ) ;
997997
998+ it . effect ( "releases delivered output while the process queue stays busy" , ( ) =>
999+ Effect . gen ( function * ( ) {
1000+ // Observe retained payloads, since delivery and bounded history alone cannot detect a leak.
1001+ let readState : Effect . Effect < unknown > = Effect . void ;
1002+ const makeRef = vi . mocked ( SynchronizedRef . make ) . getMockImplementation ( ) ! ;
1003+ using _capture = vi . spyOn ( SynchronizedRef , "make" ) . mockImplementation ( < A > ( value : A ) =>
1004+ makeRef ( value ) . pipe (
1005+ Effect . tap ( ( ref ) =>
1006+ Effect . sync ( ( ) => {
1007+ if ( typeof value === "object" && value !== null && "sessions" in value ) {
1008+ readState = SynchronizedRef . get ( ref ) ;
1009+ }
1010+ } ) ,
1011+ ) ,
1012+ ) ,
1013+ ) ;
1014+ const { manager, ptyAdapter } = yield * createManager ( 5 , { historyByteLimit : 1024 } ) ;
1015+ yield * manager . open ( openInput ( ) ) ;
1016+ const process = ptyAdapter . processes [ 0 ] ! ;
1017+ const entered = yield * Deferred . make < void > ( ) ;
1018+ const release = yield * Deferred . make < void > ( ) ;
1019+ const measured = yield * Deferred . make < void > ( ) ;
1020+ const finish = yield * Deferred . make < void > ( ) ;
1021+ const drained = yield * Deferred . make < void > ( ) ;
1022+ yield * Effect . addFinalizer ( ( ) => Deferred . succeed ( finish , undefined ) ) ;
1023+ yield * Effect . addFinalizer ( ( ) => Deferred . succeed ( release , undefined ) ) ;
1024+ const chunkBytes = 64 * 1024 ;
1025+ const chunkCount = 256 ;
1026+ let delivered = 0 ;
1027+ const unsubscribe = yield * manager . subscribe ( ( event ) =>
1028+ Effect . gen ( function * ( ) {
1029+ if ( event . type !== "output" ) return ;
1030+ delivered += 1 ;
1031+ expect ( event . data ) . toBe (
1032+ delivered === 1
1033+ ? "start"
1034+ : ( delivered === 2
1035+ ? "queued-a"
1036+ : delivered === 3
1037+ ? "queued-b"
1038+ : `${ delivered - 3 } `
1039+ ) . padEnd ( chunkBytes , "x" ) ,
1040+ ) ;
1041+ if ( delivered === 1 ) {
1042+ yield * Deferred . succeed ( entered , undefined ) ;
1043+ yield * Deferred . await ( release ) ;
1044+ }
1045+ if ( delivered === chunkCount ) {
1046+ yield * Deferred . succeed ( measured , undefined ) ;
1047+ yield * Deferred . await ( finish ) ;
1048+ } else if ( delivered < chunkCount ) {
1049+ process . emitData ( `${ delivered } ` . padEnd ( chunkBytes , "x" ) ) ;
1050+ } else if ( delivered === chunkCount + 2 ) {
1051+ yield * Deferred . succeed ( drained , undefined ) ;
1052+ }
1053+ } ) ,
1054+ ) ;
1055+ yield * Effect . addFinalizer ( ( ) => Effect . sync ( unsubscribe ) ) ;
1056+ process . emitData ( "start" ) ;
1057+ yield * Deferred . await ( entered ) ;
1058+ process . emitData ( "queued-a" . padEnd ( chunkBytes , "x" ) ) ;
1059+ process . emitData ( "queued-b" . padEnd ( chunkBytes , "x" ) ) ;
1060+ yield * Deferred . succeed ( release , undefined ) ;
1061+ yield * Deferred . await ( measured ) ;
1062+
1063+ const state = ( yield * readState ) as {
1064+ sessions : ReadonlyMap <
1065+ string ,
1066+ { pendingProcessEvents : ReadonlyArray < { data ?: string } | undefined > }
1067+ > ;
1068+ } ;
1069+ const retained = [ ...state . sessions . values ( ) ] . flatMap (
1070+ ( session ) => session . pendingProcessEvents ,
1071+ ) ;
1072+ const retainedBytes = retained . reduce (
1073+ ( bytes , event ) => bytes + ( event ?. data ?. length ?? 0 ) ,
1074+ 0 ,
1075+ ) ;
1076+ expect ( delivered ) . toBe ( chunkCount ) ;
1077+ expect ( retainedBytes ) . toBeLessThanOrEqual ( 2 * chunkBytes ) ;
1078+ expect ( retained . length ) . toBeLessThanOrEqual ( 4 ) ;
1079+ yield * Deferred . succeed ( finish , undefined ) ;
1080+ yield * Deferred . await ( drained ) ;
1081+ } ) ,
1082+ ) ;
1083+
9981084 it . effect ( "retains plain Unicode and control characters around a split query" , ( ) =>
9991085 Effect . gen ( function * ( ) {
10001086 const { manager, ptyAdapter } = yield * createManager ( ) ;
0 commit comments