Refactor mobile ordering and catalog assembly

- Replace ad hoc sorts with shared Effect order helpers
- Rework remote catalog and review/terminal lists for clearer data flow
- Keep threaded/review selection and diff adapters aligned with the new ordering logic

Author: juliusmarminge

apps/mobile/src/features/home/HomeScreen.tsx

@@ -6,6 +6,8 @@ import type {
 import { SymbolView } from "expo-symbols";
 import { useCallback, useMemo, useState } from "react";
 import { Pressable, ScrollView, View } from "react-native";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
 import { useThemeColor } from "../../lib/useThemeColor";
 
 import { AppText as Text } from "../../components/AppText";
@@ -33,6 +35,15 @@ interface ProjectGroup {
   readonly threads: ReadonlyArray<EnvironmentScopedThreadShell>;
 }
 
+const projectGroupActivityOrder = Order.mapInput(
+  Order.Struct({
+    activityAt: Order.flip(Order.Number),
+  }),
+  (group: ProjectGroup) => ({
+    activityAt: new Date(group.threads[0]!.updatedAt ?? group.threads[0]!.createdAt).getTime(),
+  }),
+);
+
 /* ─── Status indicator colors ────────────────────────────────────────── */
 
 function statusColors(thread: EnvironmentScopedThreadShell): { bg: string; fg: string } {
@@ -271,13 +282,7 @@ export function HomeScreen(props: HomeScreenProps) {
       }
     }
 
-    groups.sort((a, b) => {
-      const aTime = new Date(a.threads[0]!.updatedAt ?? a.threads[0]!.createdAt).getTime();
-      const bTime = new Date(b.threads[0]!.updatedAt ?? b.threads[0]!.createdAt).getTime();
-      return bTime - aTime;
-    });
-
-    return groups;
+    return Arr.sort(groups, projectGroupActivityOrder);
   }, [props.projects, filteredThreads]);
 
   /* Empty states */

apps/mobile/src/features/review/reviewModel.ts

@@ -2,6 +2,7 @@ import type { ChangeTypes, FileDiffMetadata } from "@pierre/diffs/types";
 import { parsePatchFiles } from "@pierre/diffs/utils/parsePatchFiles";
 import type { OrchestrationCheckpointSummary, ReviewDiffPreviewSource } from "@t3tools/contracts";
 import * as Arr from "effect/Array";
+import { pipe } from "effect/Function";
 import * as Order from "effect/Order";
 
 export type ReviewSectionKind = "turn" | "working-tree" | "branch-range";
@@ -513,9 +514,10 @@ export function getReviewSectionIdForCheckpoint(
 export function getReadyReviewCheckpoints(
   checkpoints: ReadonlyArray<OrchestrationCheckpointSummary>,
 ): ReadonlyArray<OrchestrationCheckpointSummary> {
-  return Arr.sort(
-    checkpoints.filter((checkpoint) => checkpoint.status === "ready"),
-    readyCheckpointOrder,
+  return pipe(
+    checkpoints,
+    Arr.filter((checkpoint) => checkpoint.status === "ready"),
+    Arr.sort(readyCheckpointOrder),
   );
 }
 
@@ -579,7 +581,11 @@ export function buildReviewParsedDiff(
     const parsedPatches = runDiffParserSilently(() =>
       parsePatchFiles(text, buildPatchCacheKey(text, cacheScope)),
     );
-    const files = parsedPatches.flatMap((patch) => patch.files).map(mapRenderableFile);
+    const files = pipe(
+      parsedPatches,
+      Arr.flatMap((patch) => patch.files),
+      Arr.map(mapRenderableFile),
+    );
 
     if (files.length === 0) {
       return {

apps/mobile/src/features/review/useReviewCommentSelectionController.ts

@@ -1,6 +1,9 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import type { NativeSyntheticEvent } from "react-native";
 import { useRouter } from "expo-router";
+import * as Arr from "effect/Array";
+import { pipe } from "effect/Function";
+import * as Result from "effect/Result";
 
 import type { EnvironmentId, ThreadId } from "@t3tools/contracts";
 
@@ -53,10 +56,13 @@ export function useReviewCommentSelectionController(input: {
       activeCommentTarget.sectionTitle === selectedSection?.title &&
       activeCommentTarget.startIndex !== activeCommentTarget.endIndex
     ) {
-      return getSelectedReviewCommentLines(activeCommentTarget).flatMap((line) => {
-        const rowId = nativeReviewDiffData.rowIdByCommentLineId.get(line.id);
-        return rowId ? [rowId] : [];
-      });
+      return pipe(
+        getSelectedReviewCommentLines(activeCommentTarget),
+        Arr.filterMap((line) => {
+          const rowId = nativeReviewDiffData.rowIdByCommentLineId.get(line.id);
+          return rowId ? Result.succeed(rowId) : Result.failVoid;
+        }),
+      );
     }
 
     return pendingNativeCommentSelection ? [pendingNativeCommentSelection.rowId] : [];

apps/mobile/src/features/terminal/terminalMenu.ts

@@ -1,6 +1,8 @@
 import type { KnownTerminalSession } from "@t3tools/client-runtime";
 import { DEFAULT_TERMINAL_ID, type ProjectScript } from "@t3tools/contracts";
 import { nextTerminalId, resolveTerminalSessionLabel } from "@t3tools/shared/terminalLabels";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
 
 export {
   getTerminalLabel,
@@ -18,6 +20,14 @@ export interface TerminalMenuSession {
   readonly updatedAt: string | null;
 }
 
+const terminalMenuSessionOrder = Order.make<TerminalMenuSession>((left, right) => {
+  const comparison = left.terminalId.localeCompare(right.terminalId, undefined, { numeric: true });
+  if (comparison === 0) {
+    return 0;
+  }
+  return comparison < 0 ? -1 : 1;
+});
+
 export function basename(input: string | null): string | null {
   if (!input) {
     return null;
@@ -101,9 +111,7 @@ export function buildTerminalMenuSessions(input: {
     sessionsById.set(input.currentSession.terminalId, input.currentSession);
   }
 
-  return Array.from(sessionsById.values()).sort((left, right) =>
-    left.terminalId.localeCompare(right.terminalId, undefined, { numeric: true }),
-  );
+  return Arr.sort(sessionsById.values(), terminalMenuSessionOrder);
 }
 
 export function resolveProjectScriptTerminalId(input: {

apps/mobile/src/features/threads/ThreadNavigationDrawer.tsx

@@ -1,6 +1,8 @@
 import { SymbolView } from "expo-symbols";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Modal, Pressable, ScrollView, useWindowDimensions, View } from "react-native";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
 import { Gesture, GestureDetector } from "react-native-gesture-handler";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import Animated, {
@@ -22,15 +24,16 @@ import {
   EnvironmentScopedThreadShell,
 } from "@t3tools/client-runtime";
 
-function compareThreadActivity(
-  left: EnvironmentScopedThreadShell,
-  right: EnvironmentScopedThreadShell,
-): number {
-  return (
-    new Date(right.updatedAt ?? right.createdAt).getTime() -
-      new Date(left.updatedAt ?? left.createdAt).getTime() || left.title.localeCompare(right.title)
-  );
-}
+const threadActivityOrder = Order.mapInput(
+  Order.Struct({
+    activityAt: Order.flip(Order.Number),
+    title: Order.String,
+  }),
+  (thread: EnvironmentScopedThreadShell) => ({
+    activityAt: new Date(thread.updatedAt ?? thread.createdAt).getTime(),
+    title: thread.title,
+  }),
+);
 
 export function ThreadNavigationDrawer(props: {
   readonly visible: boolean;
@@ -60,13 +63,17 @@ export function ThreadNavigationDrawer(props: {
   );
   const groupedThreads = useMemo(
     () =>
-      repositoryGroups.map((group) => ({
-        key: group.key,
-        title: group.projects[0]?.project.title ?? group.title,
-        threads: group.projects
-          .flatMap((projectGroup) => projectGroup.threads)
-          .sort(compareThreadActivity),
-      })),
+      repositoryGroups.map((group) => {
+        const threads: EnvironmentScopedThreadShell[] = [];
+        for (const projectGroup of group.projects) {
+          threads.push(...projectGroup.threads);
+        }
+        return {
+          key: group.key,
+          title: group.projects[0]?.project.title ?? group.title,
+          threads: Arr.sort(threads, threadActivityOrder),
+        };
+      }),
     [repositoryGroups],
   );
 

apps/mobile/src/state/use-remote-catalog.ts

@@ -11,23 +11,33 @@ import {
 } from "@t3tools/client-runtime";
 
 import { ConnectedEnvironmentSummary } from "./remote-runtime-types";
+import type { SavedRemoteConnection } from "../lib/connection";
 import { useShellSnapshotStates } from "./use-shell-snapshot";
 import {
   useRemoteConnectionStatus,
   useRemoteEnvironmentState,
 } from "./use-remote-environment-registry";
 
-const projectsSortOrder = Order.make<EnvironmentScopedProjectShell>(
-  (left, right) =>
-    (left.title.localeCompare(right.title) as -1 | 0 | 1) ||
-    (left.environmentId.localeCompare(right.environmentId) as -1 | 0 | 1),
+const projectsSortOrder = Order.mapInput(
+  Order.Struct({
+    title: Order.String,
+    environmentId: Order.String,
+  }),
+  (project: EnvironmentScopedProjectShell) => ({
+    title: project.title,
+    environmentId: project.environmentId,
+  }),
 );
 
-const threadsSortOrder = Order.make<EnvironmentScopedThreadShell>(
-  (left, right) =>
-    ((new Date(right.updatedAt ?? right.createdAt).getTime() -
-      new Date(left.updatedAt ?? left.createdAt).getTime()) as -1 | 0 | 1) ||
-    (left.environmentId.localeCompare(right.environmentId) as -1 | 0 | 1),
+const threadsSortOrder = Order.mapInput(
+  Order.Struct({
+    activityAt: Order.flip(Order.Number),
+    environmentId: Order.String,
+  }),
+  (thread: EnvironmentScopedThreadShell) => ({
+    activityAt: new Date(thread.updatedAt ?? thread.createdAt).getTime(),
+    environmentId: thread.environmentId,
+  }),
 );
 
 function deriveOverallConnectionState(
@@ -48,38 +58,44 @@ function deriveOverallConnectionState(
   return "disconnected";
 }
 
+function listRemoteCatalogEnvironmentIds(
+  savedConnectionsById: Readonly<Record<string, SavedRemoteConnection>>,
+): ReadonlyArray<SavedRemoteConnection["environmentId"]> {
+  const environmentIds: SavedRemoteConnection["environmentId"][] = [];
+  for (const connection of Object.values(savedConnectionsById)) {
+    environmentIds.push(connection.environmentId);
+  }
+  return environmentIds;
+}
+
 export function useRemoteCatalog() {
   const { connectedEnvironments, connectionState } = useRemoteConnectionStatus();
   const { environmentStateById, savedConnectionsById } = useRemoteEnvironmentState();
   const shellSnapshotStates = useShellSnapshotStates(
-    Object.values(savedConnectionsById).map((connection) => connection.environmentId),
+    listRemoteCatalogEnvironmentIds(savedConnectionsById),
   );
 
-  const projects = useMemo(
-    () =>
-      Arr.sort(
-        Object.values(savedConnectionsById).flatMap((connection) =>
-          (shellSnapshotStates[connection.environmentId]?.data?.projects ?? []).map((project) =>
-            scopeProjectShell(connection.environmentId, project),
-          ),
-        ),
-        projectsSortOrder,
-      ),
-    [savedConnectionsById, shellSnapshotStates],
-  );
+  const projects = useMemo(() => {
+    const scopedProjects: EnvironmentScopedProjectShell[] = [];
+    for (const connection of Object.values(savedConnectionsById)) {
+      const projects = shellSnapshotStates[connection.environmentId]?.data?.projects ?? [];
+      for (const project of projects) {
+        scopedProjects.push(scopeProjectShell(connection.environmentId, project));
+      }
+    }
+    return Arr.sort(scopedProjects, projectsSortOrder);
+  }, [savedConnectionsById, shellSnapshotStates]);
 
-  const threads = useMemo(
-    () =>
-      Arr.sort(
-        Object.values(savedConnectionsById).flatMap((connection) =>
-          (shellSnapshotStates[connection.environmentId]?.data?.threads ?? []).map((thread) =>
-            scopeThreadShell(connection.environmentId, thread),
-          ),
-        ),
-        threadsSortOrder,
-      ),
-    [savedConnectionsById, shellSnapshotStates],
-  );
+  const threads = useMemo(() => {
+    const scopedThreads: EnvironmentScopedThreadShell[] = [];
+    for (const connection of Object.values(savedConnectionsById)) {
+      const threads = shellSnapshotStates[connection.environmentId]?.data?.threads ?? [];
+      for (const thread of threads) {
+        scopedThreads.push(scopeThreadShell(connection.environmentId, thread));
+      }
+    }
+    return Arr.sort(scopedThreads, threadsSortOrder);
+  }, [savedConnectionsById, shellSnapshotStates]);
 
   const serverConfigByEnvironmentId = useMemo(
     () =>

apps/mobile/src/state/use-remote-environment-registry.ts

@@ -274,8 +274,13 @@ export async function connectSavedEnvironment(
   }
 }
 
-const environmentsSortOrder = Order.make<ConnectedEnvironmentSummary>(
-  (left, right) => left.environmentLabel.localeCompare(right.environmentLabel) as -1 | 0 | 1,
+const environmentsSortOrder = Order.mapInput(
+  Order.Struct({
+    environmentLabel: Order.String,
+  }),
+  (environment: ConnectedEnvironmentSummary) => ({
+    environmentLabel: environment.environmentLabel,
+  }),
 );
 
 function deriveConnectedEnvironments(