@@ -8,7 +8,9 @@ import * as NodePath from "node:path";
88import { ProviderDriverKind , ProviderInstanceId , type ServerProvider } from "@t3tools/contracts" ;
99import { HostProcessPlatform } from "@t3tools/shared/hostProcess" ;
1010import * as Crypto from "effect/Crypto" ;
11+ import * as Deferred from "effect/Deferred" ;
1112import * as Effect from "effect/Effect" ;
13+ import * as Fiber from "effect/Fiber" ;
1214import * as Sink from "effect/Sink" ;
1315import * as Stream from "effect/Stream" ;
1416import { HttpClient } from "effect/http" ;
@@ -902,6 +904,61 @@ it.layer(NodeServices.layer)("providerMaintenance", (it) => {
902904 expect ( resolutions ) . toBe ( 2 ) ;
903905 } ) ,
904906 ) ;
907+
908+ it . effect ( "starts a fresh read instead of joining the resolution already running" , ( ) =>
909+ Effect . gen ( function * ( ) {
910+ const releaseStale = yield * Deferred . make < void > ( ) ;
911+ let resolutions = 0 ;
912+ const resolve = yield * makeCachedProviderMaintenanceResolution (
913+ Effect . suspend ( ( ) => {
914+ resolutions += 1 ;
915+ return resolutions === 1
916+ ? Deferred . await ( releaseStale ) . pipe ( Effect . as ( manualPackageTool ) )
917+ : Effect . succeed ( manualPackageTool ) ;
918+ } ) ,
919+ ) ;
920+
921+ // An advisory read starts a resolution that is still running when the
922+ // user clicks Update; the fresh read must not wait on or reuse it.
923+ const advisory = yield * Effect . forkChild ( resolve ( ) , { startImmediately : true } ) ;
924+ const fresh = yield * Effect . forkChild ( resolve ( { fresh : true } ) , { startImmediately : true } ) ;
925+ // The fresh read runs its own resolution, so it finishes while the stale
926+ // one is still waiting.
927+ expect ( resolutions ) . toBe ( 2 ) ;
928+ expect ( fresh . pollUnsafe ( ) ) . toBeDefined ( ) ;
929+ yield * Deferred . succeed ( releaseStale , undefined ) ;
930+ expect ( yield * Fiber . join ( fresh ) ) . toEqual ( manualPackageTool ) ;
931+ yield * Fiber . join ( advisory ) ;
932+ } ) ,
933+ ) ;
934+
935+ it . effect ( "resolves again after the first read is interrupted" , ( ) =>
936+ Effect . gen ( function * ( ) {
937+ const release = yield * Deferred . make < void > ( ) ;
938+ let resolutions = 0 ;
939+ const resolve = yield * makeCachedProviderMaintenanceResolution (
940+ Effect . suspend ( ( ) => {
941+ resolutions += 1 ;
942+ return resolutions === 1
943+ ? Effect . never
944+ : Deferred . await ( release ) . pipe ( Effect . as ( manualPackageTool ) ) ;
945+ } ) ,
946+ ) ;
947+
948+ const first = yield * Effect . forkChild ( resolve ( ) , { startImmediately : true } ) ;
949+ yield * Fiber . interrupt ( first ) ;
950+
951+ // The next read resolves again, and a reader that joined it keeps it
952+ // running when the reader that started it goes away.
953+ const owner = yield * Effect . forkChild ( resolve ( ) , { startImmediately : true } ) ;
954+ const waiter = yield * Effect . forkChild ( resolve ( ) , { startImmediately : true } ) ;
955+ yield * Fiber . interrupt ( owner ) ;
956+ yield * Deferred . succeed ( release , undefined ) ;
957+ expect ( yield * Fiber . join ( waiter ) ) . toEqual ( manualPackageTool ) ;
958+ expect ( yield * resolve ( ) ) . toEqual ( manualPackageTool ) ;
959+ expect ( resolutions ) . toBe ( 2 ) ;
960+ } ) ,
961+ ) ;
905962} ) ;
906963
907964it ( "pins only owned package-manager installs and preserves their execution context" , ( ) => {
0 commit comments