Merge branch 'main' into repo-assist/eng-update-fsdocs-22alpha3-20260403-596ea5adde75c6f0

Author: dsyme

.github/aw/actions-lock.json

@@ -10,15 +10,15 @@
       "version": "v8",
       "sha": "ed597411d8f924073f98dfc5c65a23a2325f34cd"
     },
-    "github/gh-aw-actions/[email protected].4": {
+    "github/gh-aw-actions/[email protected].6": {
       "repo": "github/gh-aw-actions/setup",
-      "version": "v0.65.4",
-      "sha": "934698b44320d87a7a9196339f90293f10bd2247"
+      "version": "v0.65.6",
+      "sha": "31130b20a8fd3ef263acbe2091267c0aace07e09"
     },
-    "github/gh-aw/actions/[email protected].4": {
+    "github/gh-aw/actions/[email protected].6": {
       "repo": "github/gh-aw/actions/setup",
-      "version": "v0.65.4",
-      "sha": "b5a9fb08751b738a86b3b605ff1fdf34956adbf4"
+      "version": "v0.65.6",
+      "sha": "296262211b372a13b451ca9400369ac152db75d6"
     }
   }
 }

.github/workflows/repo-assist.lock.yml

@@ -65,6 +65,7 @@ safe-outputs:
     target: "*"
     title-prefix: "[Repo Assist] "
     max: 4
+    protected-files: fallback-to-issue
   create-issue:
     title-prefix: "[Repo Assist] "
     labels: [automation, repo-assist]
@@ -175,7 +176,7 @@ steps:
           json.dump(result, f, indent=2)
       EOF
 
-source: githubnext/agentics/workflows/repo-assist.md@e1ecf341a90b7bc2021e77c58685d7e269e20b99
+source: githubnext/agentics/workflows/repo-assist.md@4ea8c81959909f40373e2a5c2b7fdb54ea19e0a5
 ---
 
 # Repo Assist

.github/workflows/repo-assist.md

@@ -1,3 +1,11 @@
+### 4.12.0
+
+* Added `AsyncSeq.sortAsync` — asynchronous variant of `sort` returning `Async<'T[]>`, avoiding `Async.RunSynchronously` in async workflows.
+* Added `AsyncSeq.sortByAsync` — asynchronous variant of `sortBy` returning `Async<'T[]>`.
+* Added `AsyncSeq.sortDescendingAsync` — asynchronous variant of `sortDescending` returning `Async<'T[]>`.
+* Added `AsyncSeq.sortByDescendingAsync` — asynchronous variant of `sortByDescending` returning `Async<'T[]>`.
+* Added `AsyncSeq.sortWithAsync` — asynchronous variant of `sortWith` returning `Async<'T[]>`.
+
 ### 4.11.0
 
 * Updated `fsdocs-tool` to 22.0.0-alpha.3 (FSharp.Formatting 22.0.0-alpha.3) and updated SDK to .NET 10.0 (issue #300).

RELEASE_NOTES.md

@@ -2244,6 +2244,21 @@ module AsyncSeq =
   let sortWith (comparer:'T -> 'T -> int) (source:AsyncSeq<'T>) : array<'T> =
     toSortedSeq (Array.sortWith comparer) source
 
+  let sortAsync (source:AsyncSeq<'T>) : Async<array<'T>> when 'T : comparison =
+    toArrayAsync source |> Async.map Array.sort
+
+  let sortByAsync (projection:'T -> 'Key) (source:AsyncSeq<'T>) : Async<array<'T>> when 'Key : comparison =
+    toArrayAsync source |> Async.map (Array.sortBy projection)
+
+  let sortDescendingAsync (source:AsyncSeq<'T>) : Async<array<'T>> when 'T : comparison =
+    toArrayAsync source |> Async.map Array.sortDescending
+
+  let sortByDescendingAsync (projection:'T -> 'Key) (source:AsyncSeq<'T>) : Async<array<'T>> when 'Key : comparison =
+    toArrayAsync source |> Async.map (Array.sortByDescending projection)
+
+  let sortWithAsync (comparer:'T -> 'T -> int) (source:AsyncSeq<'T>) : Async<array<'T>> =
+    toArrayAsync source |> Async.map (Array.sortWith comparer)
+
   let rev (source: AsyncSeq<'T>) : AsyncSeq<'T> = asyncSeq {
       let! arr = toArrayAsync source
       for i in arr.Length - 1 .. -1 .. 0 do

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -730,6 +730,26 @@ module AsyncSeq =
     /// large or infinite sequences.
     val sortWith : comparer:('T -> 'T -> int) -> source:AsyncSeq<'T> -> array<'T>
 
+    /// Asynchronously sorts the given async sequence and returns an Async<array<'T>>.
+    /// Prefer this over sortAsync when composing async workflows.
+    val sortAsync : source:AsyncSeq<'T> -> Async<array<'T>> when 'T : comparison
+
+    /// Asynchronously applies a key-generating function to each element of an AsyncSeq and returns
+    /// an Async<array<'T>> ordered by keys. Prefer this over sortBy when composing async workflows.
+    val sortByAsync : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> Async<array<'T>> when 'Key : comparison
+
+    /// Asynchronously sorts the given async sequence in descending order and returns an Async<array<'T>>.
+    /// Prefer this over sortDescending when composing async workflows.
+    val sortDescendingAsync : source:AsyncSeq<'T> -> Async<array<'T>> when 'T : comparison
+
+    /// Asynchronously applies a key-generating function to each element of an AsyncSeq and returns
+    /// an Async<array<'T>> ordered descending by keys. Prefer this over sortByDescending when composing async workflows.
+    val sortByDescendingAsync : projection:('T -> 'Key) -> source:AsyncSeq<'T> -> Async<array<'T>> when 'Key : comparison
+
+    /// Asynchronously sorts the given async sequence using the given comparison function and returns
+    /// an Async<array<'T>>. Prefer this over sortWith when composing async workflows.
+    val sortWithAsync : comparer:('T -> 'T -> int) -> source:AsyncSeq<'T> -> Async<array<'T>>
+
     /// Returns a new async sequence with the elements in reverse order. The entire source
     /// sequence is buffered before yielding any elements, mirroring Seq.rev.
     /// This function should not be used with large or infinite sequences.

src/FSharp.Control.AsyncSeq/AsyncSeq.fsi

@@ -3456,6 +3456,47 @@ let ``AsyncSeq.sortWith returns empty array for empty sequence`` () =
   let result = AsyncSeq.sortWith compare AsyncSeq.empty<int>
   Assert.AreEqual([||], result)
 
+// ===== sortAsync / sortByAsync / sortDescendingAsync / sortByDescendingAsync / sortWithAsync =====
+
+[<Test>]
+let ``AsyncSeq.sortAsync sorts in ascending order`` () =
+  let result = AsyncSeq.ofSeq [ 3; 1; 4; 1; 5; 9 ] |> AsyncSeq.sortAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 1; 1; 3; 4; 5; 9 |], result)
+
+[<Test>]
+let ``AsyncSeq.sortAsync returns empty array for empty sequence`` () =
+  let result = AsyncSeq.empty<int> |> AsyncSeq.sortAsync |> Async.RunSynchronously
+  Assert.AreEqual([||], result)
+
+[<Test>]
+let ``AsyncSeq.sortByAsync sorts by projected key`` () =
+  let result =
+    AsyncSeq.ofSeq [ "banana"; "apple"; "cherry" ]
+    |> AsyncSeq.sortByAsync (fun s -> s.Length)
+    |> Async.RunSynchronously
+  Assert.AreEqual([| "apple"; "banana"; "cherry" |], result)
+
+[<Test>]
+let ``AsyncSeq.sortDescendingAsync sorts in descending order`` () =
+  let result = AsyncSeq.ofSeq [ 3; 1; 4; 1; 5 ] |> AsyncSeq.sortDescendingAsync |> Async.RunSynchronously
+  Assert.AreEqual([| 5; 4; 3; 1; 1 |], result)
+
+[<Test>]
+let ``AsyncSeq.sortByDescendingAsync sorts by projected key descending`` () =
+  let result =
+    AsyncSeq.ofSeq [ "apple"; "banana"; "fig" ]
+    |> AsyncSeq.sortByDescendingAsync (fun s -> s.Length)
+    |> Async.RunSynchronously
+  Assert.AreEqual([| "banana"; "apple"; "fig" |], result)
+
+[<Test>]
+let ``AsyncSeq.sortWithAsync sorts using custom comparer`` () =
+  let result =
+    AsyncSeq.ofSeq [ 3; 1; 4; 1; 5 ]
+    |> AsyncSeq.sortWithAsync (fun a b -> compare b a)
+    |> Async.RunSynchronously
+  Assert.AreEqual([| 5; 4; 3; 1; 1 |], result)
+
 // ── AsyncSeq.mapFold ──────────────────────────────────────────────────────────
 
 [<Test>]