add network.slices.slice.getSyncSummary xrpc and corresponding ui, shows a summary of the sync before syncing, limits to 5000 repos but can change via env var

api/.env.example

···
 # System slice URI
 SYSTEM_SLICE_URI=at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z
 
+# Default maximum repositories per sync operation
+DEFAULT_MAX_SYNC_REPOS=5000
+
 # Logging level
 RUST_LOG=debug
 

api/src/main.rs

···
     pub auth_base_url: String,
     pub relay_endpoint: String,
     pub system_slice_uri: String,
+    pub default_max_sync_repos: i32,
 }
 
 #[derive(Clone)]
···
         "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z".to_string()
     });
 
+    let default_max_sync_repos = env::var("DEFAULT_MAX_SYNC_REPOS")
+        .unwrap_or_else(|_| "5000".to_string())
+        .parse::<i32>()
+        .unwrap_or(5000);
+
     let config = Config {
         auth_base_url,
         relay_endpoint,
         system_slice_uri,
+        default_max_sync_repos,
     };
 
     // Initialize global logger
···
         .route(
             "/xrpc/network.slices.slice.deleteOAuthClient",
             post(xrpc::network::slices::slice::delete_oauth_client::handler),
+        )
+        .route(
+            "/xrpc/network.slices.slice.getSyncSummary",
+            get(xrpc::network::slices::slice::get_sync_summary::handler),
         )
         // Dynamic collection-specific XRPC endpoints (wildcard routes must come last)
         .route(

api/src/sync.rs

···
     /// Fetch all repositories that have records in a given collection.
     ///
     /// Uses cursor-based pagination to fetch all repos from the relay.
-    async fn get_repos_for_collection(
+    pub async fn get_repos_for_collection(
         &self,
         collection: &str,
         slice_uri: &str,

api/src/xrpc/network/slices/slice/get_sync_summary.rs

···
+use crate::{AppState, auth, errors::AppError, sync::SyncService};
+use axum::{extract::{Query, State}, http::HeaderMap, response::Json};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: String,
+    #[serde(default, deserialize_with = "deserialize_string_or_vec")]
+    pub collections: Option<Vec<String>>,
+    #[serde(default, deserialize_with = "deserialize_string_or_vec")]
+    pub external_collections: Option<Vec<String>>,
+    #[serde(default, deserialize_with = "deserialize_string_or_vec")]
+    pub repos: Option<Vec<String>>,
+}
+
+fn deserialize_string_or_vec<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::de::{self, Visitor};
+    use std::fmt;
+
+    struct StringOrVec;
+
+    impl<'de> Visitor<'de> for StringOrVec {
+        type Value = Option<Vec<String>>;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("string or list of strings")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(Some(vec![value.to_string()]))
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: de::SeqAccess<'de>,
+        {
+            let mut vec = Vec::new();
+            while let Some(item) = seq.next_element::<String>()? {
+                vec.push(item);
+            }
+            Ok(if vec.is_empty() { None } else { Some(vec) })
+        }
+
+        fn visit_none<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+
+        fn visit_unit<E>(self) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(None)
+        }
+    }
+
+    deserializer.deserialize_any(StringOrVec)
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub total_repos: i64,
+    pub capped_repos: i64,
+    pub collections_summary: Vec<CollectionSummary>,
+    pub would_be_capped: bool,
+    pub applied_limit: i32,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionSummary {
+    pub collection: String,
+    pub estimated_repos: i64,
+    pub is_external: bool,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Query(params): Query<Params>,
+) -> Result<Json<Output>, AppError> {
+    tracing::info!("getSyncSummary called with params: {:?}", params);
+
+    let token = auth::extract_bearer_token(&headers)?;
+    let _user_info = auth::verify_oauth_token_cached(
+        &token,
+        &state.config.auth_base_url,
+        Some(state.auth_cache.clone()),
+    )
+    .await?;
+
+    let slice_uri = &params.slice;
+    let primary_collections = params.collections.unwrap_or_default();
+    let external_collections = params.external_collections.unwrap_or_default();
+    let user_provided_repos = params.repos;
+
+    // Use the system default limit
+    let applied_limit = state.config.default_max_sync_repos;
+
+    // Get slice domain for categorizing collections
+    let slice_domain = state
+        .database
+        .get_slice_domain(slice_uri)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get slice domain: {}", e)))?
+        .ok_or_else(|| AppError::NotFound(format!("Slice not found: {}", slice_uri)))?;
+
+    // Create sync service for repo discovery
+    let sync_service = SyncService::with_cache(
+        state.database.clone(),
+        state.config.relay_endpoint.clone(),
+        state.auth_cache.clone(),
+    );
+
+    // Discover repos if not provided
+    let all_repos = if let Some(provided_repos) = user_provided_repos {
+        provided_repos
+    } else {
+        // Discover repos from collections
+        let mut discovered_repos = std::collections::HashSet::new();
+
+        // Get repos from primary collections
+        for collection in &primary_collections {
+            match sync_service.get_repos_for_collection(collection, slice_uri).await {
+                Ok(repos) => {
+                    discovered_repos.extend(repos);
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to get repos for collection {}: {}", collection, e);
+                }
+            }
+        }
+
+        // Get repos from external collections
+        for collection in &external_collections {
+            match sync_service.get_repos_for_collection(collection, slice_uri).await {
+                Ok(repos) => {
+                    discovered_repos.extend(repos);
+                }
+                Err(e) => {
+                    tracing::warn!("Failed to get repos for collection {}: {}", collection, e);
+                }
+            }
+        }
+
+        discovered_repos.into_iter().collect()
+    };
+
+    let total_repos = all_repos.len() as i64;
+    let capped_repos = std::cmp::min(total_repos, applied_limit as i64);
+    let would_be_capped = total_repos > applied_limit as i64;
+
+    // Build collections summary
+    let mut collections_summary = Vec::new();
+    let mut collection_repo_counts: HashMap<String, i64> = HashMap::new();
+
+    // Count repos per collection (this is an approximation)
+    for collection in &primary_collections {
+        let is_external = !collection.starts_with(&slice_domain);
+        let estimated_repos = if let Ok(repos) = sync_service.get_repos_for_collection(collection, slice_uri).await {
+            repos.len() as i64
+        } else {
+            0
+        };
+
+        collection_repo_counts.insert(collection.clone(), estimated_repos);
+        collections_summary.push(CollectionSummary {
+            collection: collection.clone(),
+            estimated_repos,
+            is_external,
+        });
+    }
+
+    for collection in &external_collections {
+        let is_external = !collection.starts_with(&slice_domain);
+        let estimated_repos = if let Ok(repos) = sync_service.get_repos_for_collection(collection, slice_uri).await {
+            repos.len() as i64
+        } else {
+            0
+        };
+
+        collection_repo_counts.insert(collection.clone(), estimated_repos);
+        collections_summary.push(CollectionSummary {
+            collection: collection.clone(),
+            estimated_repos,
+            is_external,
+        });
+    }
+
+    Ok(Json(Output {
+        total_repos,
+        capped_repos,
+        collections_summary,
+        would_be_capped,
+        applied_limit,
+    }))
+}

api/src/xrpc/network/slices/slice/mod.rs

···
 pub mod get_oauth_clients;
 pub mod get_slice_records;
 pub mod get_sparklines;
+pub mod get_sync_summary;
 pub mod openapi;
 pub mod start_sync;
 pub mod stats;

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-28 21:47:20 UTC
-// Lexicons: 41
+// Generated at: 2025-09-29 01:19:06 UTC
+// Lexicons: 42
 
 /**
  * @example Usage
···
   connected: boolean;
 }
 
+export interface NetworkSlicesSliceGetSyncSummaryParams {
+  slice: string;
+  collections?: string[];
+  externalCollections?: string[];
+  repos?: string[];
+  maxRepos?: number;
+}
+
+export interface NetworkSlicesSliceGetSyncSummaryOutput {
+  totalRepos: number;
+  cappedRepos: number;
+  collectionsSummary: NetworkSlicesSliceGetSyncSummary["CollectionSummary"][];
+  wouldBeCapped: boolean;
+  appliedLimit: number;
+}
+
+export interface NetworkSlicesSliceGetSyncSummaryCollectionSummary {
+  collection: string;
+  estimatedRepos: number;
+  isExternal: boolean;
+}
+
 export interface NetworkSlicesSlice {
   /** Name of the slice */
   name: string;
···
 
 export interface NetworkSlicesSliceGetJobLogs {
   readonly LogEntry: NetworkSlicesSliceGetJobLogsLogEntry;
+}
+
+export interface NetworkSlicesSliceGetSyncSummary {
+  readonly CollectionSummary: NetworkSlicesSliceGetSyncSummaryCollectionSummary;
 }
 
 export interface NetworkSlicesSliceGetJobStatus {
···
     return await this.client.makeRequest<
       NetworkSlicesSliceGetJetstreamStatusOutput
     >("network.slices.slice.getJetstreamStatus", "GET", {});
+  }
+
+  async getSyncSummary(
+    params?: NetworkSlicesSliceGetSyncSummaryParams,
+  ): Promise<NetworkSlicesSliceGetSyncSummaryOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetSyncSummaryOutput
+    >("network.slices.slice.getSyncSummary", "GET", params);
   }
 
   async getJobStatus(

frontend/src/features/slices/lexicon/templates/LexiconDetailPage.tsx

···
                         className="leading-relaxed"
                       >
                         When enabled, records for this lexicon will not be
-                        synced from the AT Protocol firehose or during bulk sync
+                        synced from the AT Protocol firehose or during sync
                         operations.
                       </Text>
                     </div>

frontend/src/features/slices/sync/handlers.tsx

···
 import { SliceSyncPage } from "./templates/SliceSyncPage.tsx";
 import { hxRedirect } from "../../../utils/htmx.ts";
 import { SyncFormModal } from "./templates/fragments/SyncFormModal.tsx";
+import { SyncSummaryModal } from "./templates/fragments/SyncSummaryModal.tsx";
 import { SyncResult } from "./templates/fragments/SyncResult.tsx";
 import { JobHistory } from "./templates/fragments/JobHistory.tsx";
 
···
   try {
     const formData = await req.formData();
     const collections = formData.getAll("collections") as string[];
-    const externalCollections = formData.getAll("external_collections") as string[];
+    const externalCollections = formData.getAll(
+      "external_collections"
+    ) as string[];
     const reposText = (formData.get("repos") as string) || "";
 
     const repos = reposText
···
   }
 }
 
+async function handleSyncSummary(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const context = await withAuth(req);
+  const authResponse = requireAuth(context);
+  if (authResponse) return authResponse;
+
+  const sliceId = params?.pathname.groups.id;
+  if (!sliceId) {
+    return new Response("Invalid slice ID", { status: 400 });
+  }
+
+  try {
+    const formData = await req.formData();
+    const collections = formData.getAll("collections") as string[];
+    const externalCollections = formData.getAll(
+      "external_collections"
+    ) as string[];
+    const reposText = (formData.get("repos") as string) || "";
+
+    const repos = reposText
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0);
+
+    if (collections.length === 0 && externalCollections.length === 0) {
+      return renderHTML(
+        <SyncResult
+          success={false}
+          error="Please specify at least one collection (primary or external) to sync"
+        />
+      );
+    }
+
+    const sliceClient = getSliceClient(context, sliceId);
+    const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
+
+    // Call the getSyncSummary endpoint
+    const requestParams = {
+      slice: sliceUri,
+      collections: collections.length > 0 ? collections : undefined,
+      externalCollections:
+        externalCollections.length > 0 ? externalCollections : undefined,
+      repos: repos.length > 0 ? repos : undefined,
+    };
+
+    const summaryResponse =
+      await sliceClient.network.slices.slice.getSyncSummary(requestParams);
+
+    return renderHTML(
+      <SyncSummaryModal
+        sliceId={sliceId}
+        summary={summaryResponse}
+        collections={collections}
+        externalCollections={externalCollections}
+        repos={reposText}
+      />
+    );
+  } catch (error) {
+    console.error("Failed to get sync summary:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return renderHTML(<SyncResult success={false} error={errorMessage} />);
+  }
+}
+
 export const syncRoutes: Route[] = [
   {
     method: "GET",
···
     method: "POST",
     pattern: new URLPattern({ pathname: "/api/slices/:id/sync" }),
     handler: handleSliceSync,
+  },
+  {
+    method: "POST",
+    pattern: new URLPattern({ pathname: "/api/slices/:id/sync/summary" }),
+    handler: handleSyncSummary,
   },
   {
     method: "GET",

frontend/src/features/slices/sync/templates/fragments/SyncFormModal.tsx

···
       title="Sync Collections"
       description="Sync entire collections from AT Protocol network to this slice."
     >
-      <form
-        hx-post={`/api/slices/${sliceId}/sync`}
-        hx-target="#sync-result"
-        hx-swap="innerHTML"
-        className="space-y-4"
-      >
+      <form className="space-y-4">
         <div className="space-y-2">
           <label className="block text-sm font-medium text-zinc-700 dark:text-zinc-300">
             Primary Collections
···
           </Button>
           <Button
             type="submit"
-            variant="success"
+            variant="primary"
             className="flex items-center justify-center"
+            hx-post={`/api/slices/${sliceId}/sync/summary`}
+            hx-target="#modal-container"
+            hx-swap="innerHTML"
           >
             <i
               data-lucide="loader-2"
···
               _="on load js lucide.createIcons() end"
             >
             </i>
-            <span className="htmx-indicator">Syncing...</span>
-            <span className="default-text">Start Sync</span>
+            <span className="htmx-indicator">Loading...</span>
+            <span className="default-text">Preview Sync</span>
           </Button>
         </div>
       </form>

frontend/src/features/slices/sync/templates/fragments/SyncSummaryModal.tsx

···
+import { Button } from "../../../../../shared/fragments/Button.tsx";
+import { Modal } from "../../../../../shared/fragments/Modal.tsx";
+import type { NetworkSlicesSliceGetSyncSummaryOutput } from "../../../../../client.ts";
+
+interface SyncSummaryModalProps {
+  sliceId: string;
+  summary: NetworkSlicesSliceGetSyncSummaryOutput;
+  collections: string[];
+  externalCollections: string[];
+  repos?: string;
+}
+
+export function SyncSummaryModal({
+  sliceId,
+  summary,
+  collections,
+  externalCollections,
+  repos,
+}: SyncSummaryModalProps) {
+  return (
+    <Modal
+      title="Sync Summary"
+      description="Review what will be synced before starting the operation."
+    >
+      <div className="space-y-6">
+        {/* Summary Stats */}
+        <div className="bg-zinc-50 dark:bg-zinc-800 rounded-lg p-4">
+          {summary.wouldBeCapped ? (
+            <div className="grid grid-cols-2 gap-4">
+              <div>
+                <p className="text-sm font-medium text-zinc-700 dark:text-zinc-300">
+                  Total Repositories
+                </p>
+                <p className="text-2xl font-bold text-zinc-900 dark:text-zinc-100">
+                  {summary.totalRepos.toLocaleString()}
+                </p>
+              </div>
+              <div>
+                <p className="text-sm font-medium text-zinc-700 dark:text-zinc-300">
+                  Will Sync
+                </p>
+                <p className="text-2xl font-bold text-zinc-900 dark:text-zinc-100">
+                  {summary.cappedRepos.toLocaleString()}
+                </p>
+              </div>
+            </div>
+          ) : (
+            <div className="text-center">
+              <p className="text-sm font-medium text-zinc-700 dark:text-zinc-300">
+                Repositories to Sync
+              </p>
+              <p className="text-2xl font-bold text-zinc-900 dark:text-zinc-100">
+                {summary.totalRepos.toLocaleString()}
+              </p>
+            </div>
+          )}
+
+          {summary.wouldBeCapped && (
+            <div className="mt-3 p-3 bg-yellow-50 dark:bg-yellow-900/20 border border-yellow-200 dark:border-yellow-800 rounded-md">
+              <div className="flex">
+                <i
+                  data-lucide="alert-triangle"
+                  className="h-5 w-5 text-yellow-400 mr-2 flex-shrink-0"
+                  /* @ts-ignore - Hyperscript attribute */
+                  _="on load js lucide.createIcons() end"
+                ></i>
+                <div>
+                  <p className="text-sm font-medium text-yellow-800 dark:text-yellow-200">
+                    Sync Limited
+                  </p>
+                  <p className="text-sm text-yellow-700 dark:text-yellow-300">
+                    This sync has been limited to{" "}
+                    {summary.appliedLimit.toLocaleString()} repositories.
+                  </p>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+
+        {/* Collections Breakdown */}
+        <div>
+          <h3 className="text-sm font-medium text-zinc-700 dark:text-zinc-300 mb-3">
+            Collections Breakdown
+          </h3>
+          <div className="space-y-2">
+            {summary.collectionsSummary.map((collection) => (
+              <div
+                key={collection.collection}
+                className="flex items-center justify-between p-3 bg-white dark:bg-zinc-900 border border-zinc-200 dark:border-zinc-700 rounded-md"
+              >
+                <div className="flex items-center space-x-3">
+                  <div
+                    className={`w-2 h-2 rounded-full ${
+                      collection.isExternal ? "bg-blue-500" : "bg-green-500"
+                    }`}
+                  ></div>
+                  <div>
+                    <p className="text-sm font-medium text-zinc-900 dark:text-zinc-100">
+                      {collection.collection}
+                    </p>
+                    <p className="text-xs text-zinc-500">
+                      {collection.isExternal ? "External" : "Primary"}{" "}
+                      Collection
+                    </p>
+                  </div>
+                </div>
+                <span className="text-sm font-medium text-zinc-600 dark:text-zinc-400">
+                  {collection.estimatedRepos.toLocaleString()} repos
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+
+        {/* Actions */}
+        <form
+          hx-post={`/api/slices/${sliceId}/sync`}
+          hx-target="#sync-result"
+          hx-swap="innerHTML"
+          className="space-y-4"
+        >
+          {/* Hidden inputs to pass the sync parameters */}
+          {collections.map((collection) => (
+            <input
+              key={collection}
+              type="hidden"
+              name="collections"
+              value={collection}
+            />
+          ))}
+          {externalCollections.map((collection) => (
+            <input
+              key={collection}
+              type="hidden"
+              name="external_collections"
+              value={collection}
+            />
+          ))}
+          {repos && <input type="hidden" name="repos" value={repos} />}
+
+          <div id="sync-result" className="mt-4"></div>
+
+          <div className="flex justify-end gap-3">
+            <Button
+              type="button"
+              variant="secondary"
+              /* @ts-ignore - Hyperscript attribute */
+              _="on click set #modal-container's innerHTML to ''"
+            >
+              Cancel
+            </Button>
+            <Button
+              type="submit"
+              variant="success"
+              className="flex items-center justify-center"
+            >
+              <i
+                data-lucide="loader-2"
+                className="htmx-indicator animate-spin mr-2 h-4 w-4"
+                /* @ts-ignore - Hyperscript attribute */
+                _="on load js lucide.createIcons() end"
+              ></i>
+              <span className="htmx-indicator">Starting...</span>
+              <span className="default-text">Start Sync</span>
+            </Button>
+          </div>
+        </form>
+      </div>
+    </Modal>
+  );
+}

lexicons/network/slices/slice/getSyncSummary.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getSyncSummary",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a summary of what would be synced before running a sync operation",
+      "parameters": {
+        "type": "params",
+        "required": ["slice"],
+        "properties": {
+          "slice": {
+            "type": "string",
+            "description": "URI of the slice to sync"
+          },
+          "collections": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Primary collections to sync"
+          },
+          "externalCollections": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "External collections to sync"
+          },
+          "repos": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Specific repositories to sync (DIDs)"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": [
+            "totalRepos",
+            "cappedRepos",
+            "collectionsSummary",
+            "wouldBeCapped",
+            "appliedLimit"
+          ],
+          "properties": {
+            "totalRepos": {
+              "type": "integer",
+              "description": "Total number of repositories that would be synced"
+            },
+            "cappedRepos": {
+              "type": "integer",
+              "description": "Number of repositories after applying limit"
+            },
+            "collectionsSummary": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#collectionSummary"
+              }
+            },
+            "wouldBeCapped": {
+              "type": "boolean",
+              "description": "Whether the sync would be limited by maxRepos"
+            },
+            "appliedLimit": {
+              "type": "integer",
+              "description": "The actual limit applied (user-specified or default)"
+            }
+          }
+        }
+      }
+    },
+    "collectionSummary": {
+      "type": "object",
+      "required": ["collection", "estimatedRepos", "isExternal"],
+      "properties": {
+        "collection": {
+          "type": "string"
+        },
+        "estimatedRepos": {
+          "type": "integer"
+        },
+        "isExternal": {
+          "type": "boolean"
+        }
+      }
+    }
+  }
+}

slices.json

···
 {
   "slice": "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z",
   "lexiconPath": "./lexicons",
-  "clientOutputPath": "./frontend/src/generated_client.ts"
+  "clientOutputPath": "./frontend/src/client.ts"
 }