Fix implicit search priority for async providers in tagless-final

Add AppContextAsyncProviderLookup to ensure correct priority ordering:
1. AppContextAsyncProviders in scope (highest) - from InAppContext
2. Local AppContextProvider (sync) converted to async
3. Companion-defined AppContextAsyncProvider (lowest)

This mirrors the AppContextProviderLookup pattern from core module,
ensuring that local providers (sync or async) take precedence over
companion-defined providers.

Changes:
- Add AppContextAsyncProviderLookup with three priority levels
- Add AppContextAsyncProviders.of() for explicit provider creation
- Update InAppContext.get to use the lookup mechanism
- Add AsyncImplicitsSearchOrderTest with 5 test cases

Author: rssh

tagless-final/shared/src/main/scala/com/github/rssh/appcontext/AppContextAsyncProvider.scala

@@ -41,7 +41,56 @@ object AppContextAsyncProvider extends AppContextAsyncProviderLowLevelImplicits
     summon[AppContextAsyncProvidersSearch[F, Xs]].getProvider[T, N]
 
 
+}
+
+
+/**
+ * AppContextAsyncProviderLookup is a helper trait used by InAppContext to search for async providers
+ * with correct priority:
+ * 1. AppContextAsyncProviders in enclosing scope (highest)
+ * 2. Local AppContextProvider (sync) converted via fromSyncProvider
+ * 3. AppContextAsyncProvider[F, T] defined in T's companion object (lowest)
+ *
+ * This works because implicit search looks in the companion of the result type (T),
+ * but AppContextAsyncProviderLookup[F, T]'s companion is AppContextAsyncProviderLookup, not T.
+ * So givens defined here have priority over T's companion.
+ */
+trait AppContextAsyncProviderLookup[F[_], T] {
+  def get: F[T]
+}
+
+trait AppContextAsyncProviderLookupLowPriority {
+  /**
+   * Lowest priority fallback: delegate to AppContextAsyncProvider[F, T].
+   * This picks up companion-defined async providers.
+   */
+  given fromAsyncProvider[F[_], T](using provider: AppContextAsyncProvider[F, T]): AppContextAsyncProviderLookup[F, T] with {
+    def get: F[T] = provider.get
+  }
+}
+
+trait AppContextAsyncProviderLookupMidPriority extends AppContextAsyncProviderLookupLowPriority {
+  /**
+   * Mid priority: convert sync AppContextProvider to async.
+   * Local sync providers win over companion-defined async providers.
+   */
+  given fromSyncProvider[F[_]: AppContextPure, T](using syncProvider: AppContextProvider[T]): AppContextAsyncProviderLookup[F, T] with {
+    def get: F[T] = summon[AppContextPure[F]].pure(syncProvider.get)
+  }
+}
 
+object AppContextAsyncProviderLookup extends AppContextAsyncProviderLookupMidPriority {
 
+  /**
+   * Highest priority: lookup from AppContextAsyncProviders in scope.
+   * This given is in AppContextAsyncProviderLookup companion, so it's found before
+   * any AppContextAsyncProvider[F, X] in X's companion.
+   */
+  given fromProviders[F[_], Xs <: NonEmptyTuple, X, N <: Int](
+    using providers: AppContextAsyncProvidersSearch[F, Xs],
+    idx: TupleIndex.OfSubtype[Xs, X, N]
+  ): AppContextAsyncProviderLookup[F, X] with {
+    def get: F[X] = providers.getProvider[X, N].get
+  }
 
 }

tagless-final/shared/src/main/scala/com/github/rssh/appcontext/AppContextAsyncProviders.scala

@@ -13,6 +13,21 @@ trait AppContextAsyncProviders[F[_],Xs <: NonEmptyTuple] extends AppContextAsync
 
 object AppContextAsyncProviders {
 
+ /**
+  * Accept a tuple of services and create an AppContextAsyncProviders for them.
+  * The services are wrapped in pure effect.
+  * ```
+  *   given pure: AppContextPure[F] = ...
+  *   val providers = AppContextAsyncProviders.of[F, (Service1, Service2)](service1, service2)
+  *   val depended = new Dependent(using providers)
+  * ```
+  */
+ def of[F[_], T <: NonEmptyTuple](values: T)(using pure: util.AppContextPure[F]): AppContextAsyncProviders[F, T] = {
+   val arr = values.productIterator.map { v =>
+     AppContextAsyncProvider.of[F, Any](pure.pure(v)): AppContextAsyncProvider[F, ?]
+   }.toArray
+   new DefaultAppContextAsyncProviders[F, T](arr)
+ }
 
  trait TryBuild[F[_], Xs<:NonEmptyTuple]
  case class TryBuildSuccess[F[_],Xs<:NonEmptyTuple](providers:AppContextAsyncProviders[F,Xs]) extends TryBuild[F,Xs]

tagless-final/shared/src/main/scala/com/github/rssh/appcontext/InAppContext.scala

@@ -7,10 +7,10 @@ type InAppContext[Dependencies <: NonEmptyTuple] = [F[_]] =>> AppContextAsyncPro
 object InAppContext {
 
   class FProvider[F[_]]:
-    def apply[T](using p:AppContextAsyncProvider[F,T]): F[T] =
+    def apply[T](using p:AppContextAsyncProviderLookup[F,T]): F[T] =
       p.get
 
-  def get[F[_],T](using p: AppContextAsyncProvider[F,T]): F[T] =
+  def get[F[_],T](using p: AppContextAsyncProviderLookup[F,T]): F[T] =
       p.get
 
   def get1[F[_]](using p: AppContextAsyncProvider[F,?]): FProvider[F] =
@@ -20,7 +20,7 @@ object InAppContext {
 
 extension(ac:AppContext.type)
 
-  def asyncGet[F[_],T](using p: AppContextAsyncProvider[F,T]): F[T] =
+  def asyncGet[F[_],T](using p: AppContextAsyncProviderLookup[F,T]): F[T] =
         p.get
 
 

tagless-final/shared/src/test/scala/com/github/rssh/appcontext/AsyncImplicitsSearchOrderTest.scala

@@ -0,0 +1,162 @@
+package com.github.rssh.appcontext
+
+import com.github.rssh.appcontext.util.AppContextPure
+import com.github.rssh.toymonad.ToyMonad
+import cps.*
+import cps.syntax.*
+
+import scala.concurrent.ExecutionContext.Implicits.global
+
+object AsyncImplicitsSearchOrderTestClasses {
+
+  case class Dependency1(name: String)
+
+  object Dependency1 {
+    // Async provider in companion object - should have lower priority than InAppContext providers
+    given [F[_]: CpsEffectMonad]: AppContextAsyncProvider[F, Dependency1] with {
+      def get: F[Dependency1] = summon[CpsEffectMonad[F]].pure(Dependency1("Dependency1:From companion"))
+    }
+  }
+
+  case class Dependency2(name: String)
+
+  object Dependency2 {
+    // No provider in companion - must be provided externally
+  }
+
+}
+
+class AsyncImplicitsSearchOrderTest extends munit.FunSuite {
+
+  import AsyncImplicitsSearchOrderTestClasses.*
+
+  test("AISO001: AppContextAsyncProviders takes priority over companion-defined AppContextAsyncProvider") {
+    // Dependency1 has AppContextAsyncProvider in companion returning "Dependency1:From companion"
+    // But when we use InAppContext (AppContextAsyncProviders), the value from providers should take priority
+
+    class Component1[F[_]](using CpsEffectMonad[F], InAppContext[(Dependency1, Dependency2)][F]) {
+      def getDependency1Name(): F[String] = {
+        summon[CpsEffectMonad[F]].map(InAppContext.get[F, Dependency1])(_.name)
+      }
+
+      def getDependency2Name(): F[String] = {
+        summon[CpsEffectMonad[F]].map(InAppContext.get[F, Dependency2])(_.name)
+      }
+    }
+
+    val localDep1 = Dependency1("Dependency1:From InAppContext")
+    val localDep2 = Dependency2("Dependency2:From InAppContext")
+
+    // Explicitly create providers with local values
+    given providers: AppContextAsyncProviders[ToyMonad, (Dependency1, Dependency2)] =
+      AppContextAsyncProviders.of[ToyMonad, (Dependency1, Dependency2)]((localDep1, localDep2))
+    val c1 = new Component1[ToyMonad]
+
+    val resultFuture = ToyMonad.run {
+      ToyMonad.CpsEffectToyMonad.flatMap(c1.getDependency1Name()) { name1 =>
+        ToyMonad.CpsEffectToyMonad.map(c1.getDependency2Name()) { name2 =>
+          (name1, name2)
+        }
+      }
+    }
+
+    resultFuture.map { case (name1, name2) =>
+      // Key assertion: InAppContext value should win over companion
+      assert(name1 == "Dependency1:From InAppContext",
+        s"Expected 'Dependency1:From InAppContext' but got '$name1'. " +
+        "AppContextAsyncProviders (InAppContext) should take priority over companion-defined AppContextAsyncProvider.")
+      assert(name2 == "Dependency2:From InAppContext")
+    }
+  }
+
+  test("AISO002: fallback to companion AppContextAsyncProvider when no InAppContext in scope") {
+    // When there's no InAppContext (AppContextAsyncProviders) in scope,
+    // we should fall back to the companion-defined provider
+
+    val resultFuture = ToyMonad.run {
+      AppContext.asyncGet[ToyMonad, Dependency1]
+    }
+
+    resultFuture.map { d1 =>
+      assert(d1.name == "Dependency1:From companion",
+        s"Expected 'Dependency1:From companion' but got '${d1.name}'. " +
+        "Should fall back to companion-defined AppContextAsyncProvider when no InAppContext in scope.")
+    }
+  }
+
+  test("AISO003: InAppContext.get uses lookup with correct priority") {
+    // Direct test of InAppContext.get ensuring it uses the lookup mechanism
+
+    class Service[F[_]](using CpsEffectMonad[F], InAppContext[(Dependency1 *: EmptyTuple)][F]) {
+      def getDep1(): F[Dependency1] = InAppContext.get[F, Dependency1]
+    }
+
+    val localDep1 = Dependency1("Dependency1:Local override")
+
+    // Explicitly create providers with local values
+    given providers: AppContextAsyncProviders[ToyMonad, Dependency1 *: EmptyTuple] =
+      AppContextAsyncProviders.of[ToyMonad, Dependency1 *: EmptyTuple](localDep1 *: EmptyTuple)
+    val service = new Service[ToyMonad]
+
+    val resultFuture = ToyMonad.run(service.getDep1())
+
+    resultFuture.map { d1 =>
+      assert(d1.name == "Dependency1:Local override",
+        s"Expected 'Dependency1:Local override' but got '${d1.name}'. " +
+        "InAppContext.get should use lookup that prioritizes InAppContext over companion.")
+    }
+  }
+
+  test("AISO004: Local sync AppContextProvider preferred over companion async provider") {
+    // Test that local AppContextProvider (sync) takes priority over
+    // AppContextAsyncProvider defined in companion object.
+    // The lookup mechanism converts sync providers via fromSyncProvider at mid priority,
+    // which wins over companion async providers at low priority.
+
+    val localDep1 = Dependency1("Dependency1:From local sync provider")
+
+    // Provide sync AppContextProvider - should win over companion async provider
+    given AppContextProvider[Dependency1] = AppContextProvider.of(localDep1)
+
+    val resultFuture = ToyMonad.run {
+      InAppContext.get[ToyMonad, Dependency1]
+    }
+
+    resultFuture.map { d1 =>
+      // Local sync provider should win over companion async provider
+      assert(d1.name == "Dependency1:From local sync provider",
+        s"Expected 'Dependency1:From local sync provider' but got '${d1.name}'. " +
+        "Local AppContextProvider should take priority over companion-defined AppContextAsyncProvider.")
+    }
+  }
+
+  test("AISO005: Local async AppContextAsyncProvider preferred over global sync AppContextProvider") {
+    // Test that local AppContextAsyncProvider (in InAppContext) takes priority over
+    // global/outer scope AppContextProvider (sync).
+    // The fromProviders (from InAppContext) has highest priority.
+
+    class Component[F[_]](using CpsEffectMonad[F], InAppContext[(Dependency2 *: EmptyTuple)][F]) {
+      def getDependency2(): F[Dependency2] = InAppContext.get[F, Dependency2]
+    }
+
+    // Global sync provider (lower priority)
+    given globalSync: AppContextProvider[Dependency2] = AppContextProvider.of(Dependency2("Dependency2:From global sync"))
+
+    // Local async providers via InAppContext (higher priority)
+    val localDep2 = Dependency2("Dependency2:From local async InAppContext")
+    given providers: AppContextAsyncProviders[ToyMonad, Dependency2 *: EmptyTuple] =
+      AppContextAsyncProviders.of[ToyMonad, Dependency2 *: EmptyTuple](localDep2 *: EmptyTuple)
+
+    val component = new Component[ToyMonad]
+
+    val resultFuture = ToyMonad.run(component.getDependency2())
+
+    resultFuture.map { d2 =>
+      // Local async provider (via InAppContext) should win over global sync
+      assert(d2.name == "Dependency2:From local async InAppContext",
+        s"Expected 'Dependency2:From local async InAppContext' but got '${d2.name}'. " +
+        "Local InAppContext (async) should take priority over global AppContextProvider (sync).")
+    }
+  }
+
+}