refactor api endpoints to more clear xrpc pattern, add procedure and query lexicons for slice endpoints, update codegen for query and procedure lexicons, update frontend to use the new codegen

api/src/api/actors.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::Json,
-    Json as ExtractJson,
-};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use crate::{AppState, models::{Actor, WhereCondition}};
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetActorsParams {
-    pub slice: String,
-    pub limit: Option<i32>,
-    pub cursor: Option<String>,
-    #[serde(rename = "where")]
-    pub where_conditions: Option<HashMap<String, WhereCondition>>,
-}
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetActorsResponse {
-    pub actors: Vec<Actor>,
-    pub cursor: Option<String>,
-}
-
-pub async fn get_actors(
-    State(state): State<AppState>,
-    ExtractJson(params): ExtractJson<GetActorsParams>,
-) -> Result<Json<GetActorsResponse>, StatusCode> {
-    match state.database.get_slice_actors(
-        &params.slice,
-        params.limit,
-        params.cursor.as_deref(),
-        params.where_conditions.as_ref(),
-    ).await {
-        Ok((actors, cursor)) => {
-            let response = GetActorsResponse {
-                actors,
-                cursor,
-            };
-            Ok(Json(response))
-        },
-        Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
-    }
-}

api/src/api/jetstream.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::Json as ResponseJson,
-};
-use serde::Serialize;
-use std::sync::atomic::Ordering;
-use crate::AppState;
-
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct JetstreamStatusResponse {
-    connected: bool,
-    status: String,
-    error: Option<String>,
-}
-
-pub async fn get_jetstream_status(
-    State(state): State<AppState>,
-) -> Result<ResponseJson<JetstreamStatusResponse>, StatusCode> {
-    let connected = state.jetstream_connected.load(Ordering::Relaxed);
-    
-    let (status, error) = if connected {
-        ("Connected".to_string(), None)
-    } else {
-        ("Disconnected".to_string(), Some("Jetstream consumer is not connected".to_string()))
-    };
-    
-    Ok(ResponseJson(JetstreamStatusResponse {
-        connected,
-        status,
-        error,
-    }))
-}

api/src/api/jobs.rs

···
-use axum::{
-    extract::{Query, State},
-    http::StatusCode,
-    response::Json,
-};
-use serde::Deserialize;
-use uuid::Uuid;
-use crate::AppState;
-use crate::jobs;
-
-/// Query parameters for getting job status
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetJobStatusQuery {
-    pub job_id: Uuid,
-}
-
-/// Query parameters for getting slice job history
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetSliceJobHistoryQuery {
-    pub user_did: String,
-    pub slice_uri: String,
-    pub limit: Option<i64>,
-}
-
-/// Get the status of a specific job by ID (XRPC style)
-pub async fn get_job_status(
-    State(state): State<AppState>,
-    Query(query): Query<GetJobStatusQuery>,
-) -> Result<Json<jobs::JobStatus>, StatusCode> {
-    match jobs::get_job_status(&state.database_pool, query.job_id).await {
-        Ok(Some(status)) => Ok(Json(status)),
-        Ok(None) => Err(StatusCode::NOT_FOUND),
-        Err(e) => {
-            tracing::error!("Failed to get job status: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-/// Get job history for a specific slice (XRPC style)
-pub async fn get_slice_job_history(
-    State(state): State<AppState>,
-    Query(query): Query<GetSliceJobHistoryQuery>,
-) -> Result<Json<Vec<jobs::JobStatus>>, StatusCode> {
-    match jobs::get_slice_job_history(
-        &state.database_pool, 
-        &query.user_did, 
-        &query.slice_uri, 
-        query.limit
-    ).await {
-        Ok(history) => Ok(Json(history)),
-        Err(e) => {
-            tracing::error!("Failed to get slice job history: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}

api/src/api/logs.rs

···
-use axum::{
-    extract::{Query, State},
-    http::StatusCode,
-    response::Json,
-};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{AppState, logging::{get_sync_job_logs, get_jetstream_logs, LogEntry}};
-
-#[derive(Debug, Deserialize)]
-pub struct LogsQuery {
-    pub limit: Option<i64>,
-    pub slice: Option<String>,
-}
-
-#[derive(Debug, Serialize)]
-pub struct LogsResponse {
-    pub logs: Vec<LogEntry>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LogsQueryWithJobId {
-    pub job_id: Uuid,
-    pub limit: Option<i64>,
-}
-
-/// Get logs for a specific sync job
-pub async fn get_sync_job_logs_handler(
-    State(state): State<AppState>,
-    Query(params): Query<LogsQueryWithJobId>,
-) -> Result<Json<LogsResponse>, StatusCode> {
-    match get_sync_job_logs(&state.database_pool, params.job_id, params.limit).await {
-        Ok(logs) => Ok(Json(LogsResponse { logs })),
-        Err(e) => {
-            tracing::error!("Failed to get sync job logs: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}
-
-/// Get jetstream logs
-pub async fn get_jetstream_logs_handler(
-    State(state): State<AppState>,
-    Query(params): Query<LogsQuery>,
-) -> Result<Json<LogsResponse>, StatusCode> {
-    // Debug logging to see what slice filter is being used
-    if let Some(slice) = &params.slice {
-        tracing::info!("Filtering jetstream logs by slice: {}", slice);
-    } else {
-        tracing::info!("No slice filter applied - returning all jetstream logs");
-    }
-
-    match get_jetstream_logs(&state.database_pool, params.slice.as_deref(), params.limit).await {
-        Ok(logs) => {
-            tracing::info!("Returning {} jetstream logs", logs.len());
-            Ok(Json(LogsResponse { logs }))
-        },
-        Err(e) => {
-            tracing::error!("Failed to get jetstream logs: {}", e);
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        }
-    }
-}

api/src/api/mod.rs

···
-pub mod actors;
-pub mod jetstream;
-pub mod jobs;
-pub mod logs;
-pub mod oauth;
 pub mod openapi;
-pub mod records;
-pub mod sparkline;
-pub mod stats;
-pub mod sync;
-pub mod upload_blob;
 pub mod xrpc_dynamic;

api/src/api/oauth.rs

···
-use axum::{
-    extract::{Query, State},
-    http::HeaderMap,
-    response::Json,
-    Json as ExtractJson,
-};
-use serde::{Deserialize, Serialize};
-use reqwest::Client;
-
-use crate::{
-    AppState,
-    auth,
-    errors::AppError,
-    models::{
-        CreateOAuthClientRequest, OAuthClientDetails, ListOAuthClientsResponse,
-        UpdateOAuthClientRequest, DeleteOAuthClientResponse
-    },
-};
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetOAuthClientsQuery {
-    pub slice: String,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DeleteOAuthClientRequest {
-    pub client_id: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-struct AipClientRegistrationRequest {
-    pub client_name: String,
-    pub redirect_uris: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub grant_types: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub response_types: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub scope: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub client_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub logo_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tos_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub policy_uri: Option<String>,
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-struct AipClientRegistrationResponse {
-    pub client_id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub client_secret: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub registration_access_token: Option<String>,
-    pub client_name: String,
-    pub redirect_uris: Vec<String>,
-    pub grant_types: Vec<String>,
-    pub response_types: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub scope: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub client_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub logo_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tos_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub policy_uri: Option<String>,
-    // Additional fields that AIP returns but we don't need to send
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub token_endpoint_auth_method: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub registration_client_uri: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub client_id_issued_at: Option<i64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub client_secret_expires_at: Option<i64>,
-}
-
-pub async fn create_oauth_client(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    ExtractJson(request): ExtractJson<CreateOAuthClientRequest>,
-) -> Result<Json<serde_json::Value>, AppError> {
-    // Debug log the incoming request
-    tracing::debug!("Incoming OAuth client registration request: {:?}", request);
-
-    // Validate request
-    if request.client_name.trim().is_empty() {
-        return Err(AppError::BadRequest("Client name cannot be empty".to_string()));
-    }
-
-    if request.redirect_uris.is_empty() {
-        return Err(AppError::BadRequest("At least one redirect URI is required".to_string()));
-    }
-
-    // Validate redirect URIs have basic URL format
-    for uri in &request.redirect_uris {
-        if !uri.starts_with("http://") && !uri.starts_with("https://") {
-            return Err(AppError::BadRequest(format!("Redirect URI must use HTTP or HTTPS: {}", uri)));
-        }
-        if uri.trim().is_empty() {
-            return Err(AppError::BadRequest("Redirect URI cannot be empty".to_string()));
-        }
-    }
-
-    // Extract and verify authentication
-    let token = auth::extract_bearer_token(&headers)
-        .map_err(|_| AppError::BadRequest("Missing or invalid Authorization header".to_string()))?;
-    let user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url).await
-        .map_err(|_| AppError::BadRequest("Invalid or expired access token".to_string()))?;
-
-    let user_did = user_info.sub;
-
-    // Register client with AIP
-    let aip_base_url = &state.config.auth_base_url;
-
-    let client = Client::new();
-    let aip_request = AipClientRegistrationRequest {
-        client_name: request.client_name.clone(),
-        redirect_uris: request.redirect_uris.clone(),
-        grant_types: request.grant_types.clone(),
-        response_types: request.response_types.clone(),
-        scope: request.scope.clone(),
-        client_uri: request.client_uri.clone(),
-        logo_uri: request.logo_uri.clone(),
-        tos_uri: request.tos_uri.clone(),
-        policy_uri: request.policy_uri.clone(),
-    };
-
-    let registration_url = format!("{}/oauth/clients/register", aip_base_url);
-    tracing::debug!("Attempting to register OAuth client at: {}", registration_url);
-    tracing::debug!("Sending AIP request: {:?}", aip_request);
-
-    let aip_response = client
-        .post(&registration_url)
-        .json(&aip_request)
-        .send()
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to register client with AIP: {}", e)))?;
-
-    let status = aip_response.status();
-    tracing::debug!("AIP registration response status: {}", status);
-
-    if !status.is_success() {
-        let error_text = aip_response.text().await.unwrap_or_else(|_| "Unknown error".to_string());
-        tracing::error!("AIP registration failed with status {}: {}", status, error_text);
-
-        // Try to parse the error response as JSON to get more details
-        let detailed_error = if let Ok(error_json) = serde_json::from_str::<serde_json::Value>(&error_text) {
-            if let Some(error_desc) = error_json.get("error_description").and_then(|v| v.as_str()) {
-                error_desc.to_string()
-            } else if let Some(error) = error_json.get("error").and_then(|v| v.as_str()) {
-                error.to_string()
-            } else {
-                error_text
-            }
-        } else {
-            error_text
-        };
-
-        // Return success=false with detailed error message instead of HTTP error
-        return Ok(Json(serde_json::json!({
-            "success": false,
-            "message": detailed_error
-        })));
-    }
-
-    tracing::debug!("Parsing AIP response JSON...");
-
-    // Get the response body as text first to debug what we're receiving
-    let response_body = aip_response
-        .text()
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to get response body: {}", e)))?;
-
-    tracing::debug!("AIP response body: {}", response_body);
-
-    // Try to parse the JSON from the text
-    let aip_client: AipClientRegistrationResponse = serde_json::from_str(&response_body)
-        .map_err(|e| {
-            tracing::error!("Failed to parse AIP response JSON: {}", e);
-            tracing::error!("Raw response was: {}", response_body);
-            AppError::Internal(format!("Failed to parse AIP response: {}", e))
-        })?;
-
-    tracing::debug!("Successfully parsed AIP response, client_id: {}", aip_client.client_id);
-
-    // Store the client info in our database
-    tracing::debug!("Storing OAuth client in database...");
-    let oauth_client = state.database
-        .create_oauth_client(
-            &request.slice_uri,
-            &aip_client.client_id,
-            aip_client.registration_access_token.as_deref(),
-            &user_did,
-        )
-        .await
-        .map_err(|e| {
-            tracing::error!("Failed to store OAuth client in database: {}", e);
-            AppError::Internal(format!("Failed to store OAuth client: {}", e))
-        })?;
-
-    tracing::debug!("Successfully stored OAuth client in database");
-
-    // Return the full client details from AIP
-    let response = OAuthClientDetails {
-        client_id: aip_client.client_id,
-        client_secret: aip_client.client_secret,
-        client_name: aip_client.client_name,
-        redirect_uris: aip_client.redirect_uris,
-        grant_types: aip_client.grant_types,
-        response_types: aip_client.response_types,
-        scope: aip_client.scope,
-        client_uri: aip_client.client_uri,
-        logo_uri: aip_client.logo_uri,
-        tos_uri: aip_client.tos_uri,
-        policy_uri: aip_client.policy_uri,
-        created_at: oauth_client.created_at,
-        created_by_did: oauth_client.created_by_did,
-    };
-
-    Ok(Json(serde_json::to_value(response).unwrap()))
-}
-
-pub async fn get_oauth_clients(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    Query(params): Query<GetOAuthClientsQuery>,
-) -> Result<Json<ListOAuthClientsResponse>, AppError> {
-    tracing::debug!("get_oauth_clients called with slice parameter: {}", params.slice);
-
-    // Log all headers for debugging
-    tracing::debug!("Request headers: {:?}", headers);
-
-    // Extract and verify authentication
-    let token = auth::extract_bearer_token(&headers)
-        .map_err(|e| {
-            tracing::error!("Failed to extract bearer token: {:?}", e);
-            AppError::BadRequest("Missing or invalid Authorization header".to_string())
-        })?;
-
-    tracing::debug!("Extracted bearer token (first 20 chars): {}...",
-        if token.len() > 20 { &token[..20] } else { &token });
-
-    auth::verify_oauth_token(&token, &state.config.auth_base_url).await
-        .map_err(|e| {
-            tracing::error!("OAuth token verification failed: {:?}", e);
-            AppError::BadRequest("Invalid or expired access token".to_string())
-        })?;
-
-    tracing::debug!("OAuth token verification successful");
-
-    // Get clients from our database
-    let clients = state.database
-        .get_oauth_clients_for_slice(&params.slice)
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to fetch OAuth clients: {}", e)))?;
-
-    tracing::debug!("Found {} OAuth clients in database for slice: {}", clients.len(), params.slice);
-
-    if clients.is_empty() {
-        return Ok(Json(ListOAuthClientsResponse { clients: vec![] }));
-    }
-
-    // Fetch detailed info from AIP for each client
-    let aip_base_url = &state.config.auth_base_url;
-    let client = Client::new();
-    let mut client_details = Vec::new();
-
-    for oauth_client in clients {
-        // Fetch client details from AIP
-        let aip_url = format!("{}/oauth/clients/{}", aip_base_url, oauth_client.client_id);
-        tracing::debug!("Fetching client details from AIP: {}", aip_url);
-
-        // Use registration access token if available for authentication
-        let mut request_builder = client.get(&aip_url);
-        if let Some(token) = &oauth_client.registration_access_token {
-            request_builder = request_builder.bearer_auth(token);
-            tracing::debug!("Using registration access token for authentication");
-        } else {
-            tracing::debug!("No registration access token available");
-        }
-
-        let aip_response = request_builder.send().await;
-
-        match aip_response {
-            Ok(response) => {
-                let status = response.status();
-                tracing::debug!("AIP response status for {}: {}", oauth_client.client_id, status);
-
-                if status.is_success() {
-                    // Get the response body as text first to log it
-                    match response.text().await {
-                        Ok(response_text) => {
-                            tracing::debug!("AIP response body for {}: {}", oauth_client.client_id, response_text);
-
-                            // Try to parse the JSON
-                            match serde_json::from_str::<AipClientRegistrationResponse>(&response_text) {
-                                Ok(aip_client) => {
-                                    tracing::debug!("Successfully parsed AIP client details for {}", oauth_client.client_id);
-                                    client_details.push(OAuthClientDetails {
-                                        client_id: aip_client.client_id,
-                                        client_secret: aip_client.client_secret,
-                                        client_name: aip_client.client_name,
-                                        redirect_uris: aip_client.redirect_uris,
-                                        grant_types: aip_client.grant_types,
-                                        response_types: aip_client.response_types,
-                                        scope: aip_client.scope,
-                                        client_uri: aip_client.client_uri,
-                                        logo_uri: aip_client.logo_uri,
-                                        tos_uri: aip_client.tos_uri,
-                                        policy_uri: aip_client.policy_uri,
-                                        created_at: oauth_client.created_at,
-                                        created_by_did: oauth_client.created_by_did,
-                                    });
-                                }
-                                Err(parse_error) => {
-                                    tracing::error!("Failed to parse AIP client JSON for {}: {}", oauth_client.client_id, parse_error);
-                                }
-                            }
-                        }
-                        Err(text_error) => {
-                            tracing::error!("Failed to get AIP response text for {}: {}", oauth_client.client_id, text_error);
-                        }
-                    }
-                } else {
-                    // Handle non-success status codes
-                    match response.text().await {
-                        Ok(error_text) => {
-                            tracing::error!("AIP client fetch failed with status {} for {}: {}", status, oauth_client.client_id, error_text);
-                        }
-                        Err(_) => {
-                            tracing::error!("AIP client fetch failed with status {} for {}", status, oauth_client.client_id);
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                tracing::error!("AIP client fetch error for {}: {}", oauth_client.client_id, e);
-                // If we can't fetch from AIP, create a minimal response
-                client_details.push(OAuthClientDetails {
-                    client_id: oauth_client.client_id.clone(),
-                    client_secret: None,
-                    client_name: "Unknown".to_string(),
-                    redirect_uris: vec![],
-                    grant_types: vec!["authorization_code".to_string()],
-                    response_types: vec!["code".to_string()],
-                    scope: None,
-                    client_uri: None,
-                    logo_uri: None,
-                    tos_uri: None,
-                    policy_uri: None,
-                    created_at: oauth_client.created_at,
-                    created_by_did: oauth_client.created_by_did,
-                });
-            }
-        }
-    }
-
-    Ok(Json(ListOAuthClientsResponse { clients: client_details }))
-}
-
-pub async fn update_oauth_client(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    ExtractJson(request): ExtractJson<UpdateOAuthClientRequest>,
-) -> Result<Json<serde_json::Value>, AppError> {
-    let client_id = request.client_id.clone();
-    
-    // Extract and verify authentication
-    let token = auth::extract_bearer_token(&headers)
-        .map_err(|_| AppError::BadRequest("Missing or invalid Authorization header".to_string()))?;
-    auth::verify_oauth_token(&token, &state.config.auth_base_url).await
-        .map_err(|_| AppError::BadRequest("Invalid or expired access token".to_string()))?;
-
-    // Get the client from our database to get the registration access token
-    let oauth_client = state.database
-        .get_oauth_client_by_id(&client_id)
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to fetch OAuth client: {}", e)))?
-        .ok_or_else(|| AppError::NotFound("OAuth client not found".to_string()))?;
-
-    let registration_token = oauth_client.registration_access_token
-        .ok_or_else(|| AppError::Internal("Client missing registration access token".to_string()))?;
-
-    // Build AIP update request
-    let aip_request = AipClientRegistrationRequest {
-        client_name: request.client_name.unwrap_or_default(),
-        redirect_uris: request.redirect_uris.unwrap_or_default(),
-        grant_types: None, // Keep existing
-        response_types: None, // Keep existing
-        scope: request.scope,
-        client_uri: request.client_uri,
-        logo_uri: request.logo_uri,
-        tos_uri: request.tos_uri,
-        policy_uri: request.policy_uri,
-    };
-
-    let aip_base_url = &state.config.auth_base_url;
-    let client = Client::new();
-    let update_url = format!("{}/oauth/clients/{}", aip_base_url, client_id);
-    
-    tracing::debug!("Updating OAuth client at: {}", update_url);
-    tracing::debug!("Sending AIP update request: {:?}", aip_request);
-
-    let aip_response = client
-        .put(&update_url)
-        .bearer_auth(&registration_token)
-        .json(&aip_request)
-        .send()
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to update client with AIP: {}", e)))?;
-
-    let status = aip_response.status();
-    tracing::debug!("AIP update response status: {}", status);
-
-    if !status.is_success() {
-        let error_text = aip_response.text().await.unwrap_or_else(|_| "Unknown error".to_string());
-        tracing::error!("AIP update failed with status {}: {}", status, error_text);
-
-        // Try to parse the error response as JSON to get more details
-        let detailed_error = if let Ok(error_json) = serde_json::from_str::<serde_json::Value>(&error_text) {
-            if let Some(error_desc) = error_json.get("error_description").and_then(|v| v.as_str()) {
-                error_desc.to_string()
-            } else if let Some(error) = error_json.get("error").and_then(|v| v.as_str()) {
-                error.to_string()
-            } else {
-                error_text
-            }
-        } else {
-            error_text
-        };
-
-        // Return success=false with detailed error message instead of HTTP error
-        return Ok(Json(serde_json::json!({
-            "success": false,
-            "message": detailed_error
-        })));
-    }
-
-    // Parse the response
-    let response_body = aip_response
-        .text()
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to get response body: {}", e)))?;
-
-    tracing::debug!("AIP update response body: {}", response_body);
-
-    let aip_client: AipClientRegistrationResponse = serde_json::from_str(&response_body)
-        .map_err(|e| {
-            tracing::error!("Failed to parse AIP response JSON: {}", e);
-            AppError::Internal(format!("Failed to parse AIP response: {}", e))
-        })?;
-
-    // Return the updated client details
-    let response = OAuthClientDetails {
-        client_id: aip_client.client_id,
-        client_secret: aip_client.client_secret,
-        client_name: aip_client.client_name,
-        redirect_uris: aip_client.redirect_uris,
-        grant_types: aip_client.grant_types,
-        response_types: aip_client.response_types,
-        scope: aip_client.scope,
-        client_uri: aip_client.client_uri,
-        logo_uri: aip_client.logo_uri,
-        tos_uri: aip_client.tos_uri,
-        policy_uri: aip_client.policy_uri,
-        created_at: oauth_client.created_at,
-        created_by_did: oauth_client.created_by_did,
-    };
-
-    Ok(Json(serde_json::to_value(response).unwrap()))
-}
-
-pub async fn delete_oauth_client(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    ExtractJson(request): ExtractJson<DeleteOAuthClientRequest>,
-) -> Result<Json<DeleteOAuthClientResponse>, AppError> {
-    let client_id = request.client_id;
-    // Extract and verify authentication
-    let token = auth::extract_bearer_token(&headers)
-        .map_err(|_| AppError::BadRequest("Missing or invalid Authorization header".to_string()))?;
-    auth::verify_oauth_token(&token, &state.config.auth_base_url).await
-        .map_err(|_| AppError::BadRequest("Invalid or expired access token".to_string()))?;
-
-    // Get the client from our database first
-    let oauth_client = state.database
-        .get_oauth_client_by_id(&client_id)
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to fetch OAuth client: {}", e)))?
-        .ok_or_else(|| AppError::NotFound("OAuth client not found".to_string()))?;
-
-    // Delete from AIP if we have a registration access token
-    if let Some(registration_token) = &oauth_client.registration_access_token {
-        let aip_base_url = &state.config.auth_base_url;
-
-        let client = Client::new();
-        let _aip_response = client
-            .delete(&format!("{}/oauth/clients/{}", aip_base_url, client_id))
-            .bearer_auth(registration_token)
-            .send()
-            .await;
-        // We continue even if AIP deletion fails, as we want to clean up our database
-    }
-
-    // Delete from our database
-    state.database
-        .delete_oauth_client(&client_id)
-        .await
-        .map_err(|e| AppError::Internal(format!("Failed to delete OAuth client: {}", e)))?;
-
-    Ok(Json(DeleteOAuthClientResponse {
-        success: true,
-        message: format!("OAuth client {} deleted successfully", client_id),
-    }))
-}

api/src/api/openapi.rs

···
 fn create_record_schema_from_lexicon(lexicon_data: Option<&serde_json::Value>, slice_uri: &str) -> OpenApiSchema {
     if let Some(lexicon) = lexicon_data {
         // Get the definitions object directly (it's already parsed JSON, not a string)
-        if let Some(definitions) = lexicon.get("defs") {
-                if let Some(main_def) = definitions.get("main") {
-                    if let Some(record_def) = main_def.get("record") {
-                        if let Some(properties) = record_def.get("properties") {
+        if let Some(definitions) = lexicon.get("defs")
+                && let Some(main_def) = definitions.get("main")
+                    && let Some(record_def) = main_def.get("record")
+                        && let Some(properties) = record_def.get("properties") {
                     // Convert lexicon properties to OpenAPI schema properties
                     let mut openapi_props = HashMap::new();
                     let mut required_fields = Vec::new();
 
                     // Get required fields from record level
-                    if let Some(required_array) = record_def.get("required") {
-                        if let Some(required_list) = required_array.as_array() {
+                    if let Some(required_array) = record_def.get("required")
+                        && let Some(required_list) = required_array.as_array() {
                             for req_field in required_list {
                                 if let Some(field_name) = req_field.as_str() {
                                     required_fields.push(field_name.to_string());
                                 }
                             }
                         }
-                    }
 
                     let default_example = if let Some(props_obj) = properties.as_object() {
                         for (prop_name, prop_def) in props_obj {
···
                         default: default_example,
                     };
                         }
-                    }
-                }
-        }
     }
 
     // Fallback to generic object schema (without rkey - that's a separate request parameter)
···
             default: None,
         }),
         "array" => {
-            if let Some(items_def) = prop_def.get("items") {
-                if let Some(items_schema) = convert_lexicon_property_to_openapi(items_def) {
+            if let Some(items_def) = prop_def.get("items")
+                && let Some(items_schema) = convert_lexicon_property_to_openapi(items_def) {
                     return Some(OpenApiSchema {
                         schema_type: "array".to_string(),
                         format: None,
···
                         default: None,
                     });
                 }
-            }
             Some(OpenApiSchema {
                 schema_type: "array".to_string(),
                 format: None,
···
     where_conditions.insert("indexedAt".to_string(), where_condition_schema.clone());
     
     // Extract fields from lexicon if available
-    if let Some(lexicon) = lexicon_data {
-        if let Some(definitions) = lexicon.get("definitions").or_else(|| lexicon.get("defs")) {
-            if let Some(main_def) = definitions.get("main") {
-                if let Some(record_def) = main_def.get("record") {
-                    if let Some(record_properties) = record_def.get("properties") {
-                        if let Some(props_obj) = record_properties.as_object() {
+    if let Some(lexicon) = lexicon_data
+        && let Some(definitions) = lexicon.get("definitions").or_else(|| lexicon.get("defs"))
+            && let Some(main_def) = definitions.get("main")
+                && let Some(record_def) = main_def.get("record")
+                    && let Some(record_properties) = record_def.get("properties")
+                        && let Some(props_obj) = record_properties.as_object() {
                             for field_name in props_obj.keys() {
                                 where_conditions.insert(field_name.clone(), where_condition_schema.clone());
                             }
                         }
-                    }
-                }
-            }
-        }
-    }
     
     properties.insert("where".to_string(), OpenApiSchema {
         schema_type: "object".to_string(),

api/src/api/records.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::Json,
-};
-use crate::models::{SliceRecordsParams, SliceRecordsOutput, IndexedRecord};
-use crate::AppState;
-
-pub async fn get_records(
-    State(state): State<AppState>,
-    axum::extract::Json(params): axum::extract::Json<SliceRecordsParams>,
-) -> Result<Json<SliceRecordsOutput>, StatusCode> {
-    match get_slice_records(&state, &params).await {
-        Ok(output) => Ok(Json(output)),
-        Err(_) => Ok(Json(SliceRecordsOutput {
-            success: false,
-            records: vec![],
-            cursor: None,
-            message: Some("Failed to get slice records".to_string()),
-        })),
-    }
-}
-
-async fn get_slice_records(state: &AppState, params: &SliceRecordsParams) -> Result<SliceRecordsOutput, Box<dyn std::error::Error + Send + Sync>> {
-    let (records, cursor) = state.database.get_slice_collections_records(
-        &params.slice,
-        params.limit,
-        params.cursor.as_deref(),
-        params.sort_by.as_ref(),
-        params.where_clause.as_ref(),
-    ).await?;
-
-    // Transform Record to IndexedRecord for the response
-    let indexed_records: Vec<IndexedRecord> = records.into_iter().map(|record| IndexedRecord {
-        uri: record.uri,
-        cid: record.cid,
-        did: record.did,
-        collection: record.collection,
-        value: record.json,
-        indexed_at: record.indexed_at.to_rfc3339(),
-    }).collect();
-
-    Ok(SliceRecordsOutput {
-        success: true,
-        records: indexed_records,
-        cursor,
-        message: None,
-    })
-}

api/src/api/sparkline.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::Json,
-};
-use crate::models::{GetSparklinesParams, GetSparklinesOutput};
-use crate::AppState;
-
-pub async fn batch_sparkline(
-    State(state): State<AppState>,
-    axum::extract::Json(params): axum::extract::Json<GetSparklinesParams>,
-) -> Result<Json<GetSparklinesOutput>, StatusCode> {
-    match get_batch_sparkline_data(&state, &params).await {
-        Ok(output) => Ok(Json(output)),
-        Err(_) => Ok(Json(GetSparklinesOutput {
-            success: false,
-            sparklines: std::collections::HashMap::new(),
-            message: Some("Failed to get batch sparkline data".to_string()),
-        })),
-    }
-}
-
-async fn get_batch_sparkline_data(
-    state: &AppState,
-    params: &GetSparklinesParams,
-) -> Result<GetSparklinesOutput, Box<dyn std::error::Error + Send + Sync>> {
-    let interval = params.interval.as_deref().unwrap_or("hour");
-    let duration = params.duration.as_deref().unwrap_or("24h");
-
-    // Parse duration
-    let duration_hours = match duration {
-        "1h" => 1,
-        "24h" => 24,
-        "7d" => 24 * 7,
-        "30d" => 24 * 30,
-        _ => 24, // default to 24h
-    };
-
-    let sparklines = state.database.get_batch_sparkline_data(
-        &params.slices,
-        interval,
-        duration_hours,
-    ).await?;
-
-    Ok(GetSparklinesOutput {
-        success: true,
-        sparklines,
-        message: None,
-    })
-}

api/src/api/stats.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::Json,
-};
-use crate::models::{SliceStatsOutput, SliceStatsParams};
-use crate::AppState;
-
-pub async fn stats(
-    State(state): State<AppState>,
-    axum::extract::Json(params): axum::extract::Json<SliceStatsParams>,
-) -> Result<Json<SliceStatsOutput>, StatusCode> {
-    match get_slice_stats(&state, &params.slice).await {
-        Ok(stats) => Ok(Json(stats)),
-        Err(_) => Ok(Json(SliceStatsOutput {
-            success: false,
-            collections: vec![],
-            collection_stats: vec![],
-            total_lexicons: 0,
-            total_records: 0,
-            total_actors: 0,
-            message: Some("Failed to get slice statistics".to_string()),
-        })),
-    }
-}
-
-async fn get_slice_stats(state: &AppState, slice_uri: &str) -> Result<SliceStatsOutput, Box<dyn std::error::Error + Send + Sync>> {
-    // Get all the slice-specific data in parallel
-    let (collections, collection_stats, total_lexicons, total_records, total_actors) = tokio::try_join!(
-        state.database.get_slice_collections_list(slice_uri),
-        state.database.get_slice_collection_stats(slice_uri),
-        state.database.get_slice_lexicon_count(slice_uri),
-        state.database.get_slice_total_records(slice_uri),
-        state.database.get_slice_total_actors(slice_uri),
-    )?;
-
-    Ok(SliceStatsOutput {
-        success: true,
-        collections,
-        collection_stats,
-        total_lexicons,
-        total_records,
-        total_actors,
-        message: None,
-    })
-}

api/src/api/sync.rs

···
-use crate::AppState;
-use crate::auth;
-use crate::jobs;
-use crate::models::BulkSyncParams;
-use axum::{
-    extract::State,
-    http::{HeaderMap, StatusCode},
-    response::Json,
-};
-use serde::{Deserialize, Serialize};
-use tracing::{info, warn};
-use uuid::Uuid;
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SyncRequest {
-    #[serde(flatten)]
-    pub params: BulkSyncParams,
-    pub slice: String,
-}
-
-#[derive(Debug, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SyncJobResponse {
-    pub success: bool,
-    pub job_id: Option<Uuid>,
-    pub message: String,
-}
-
-pub async fn sync(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    axum::extract::Json(request): axum::extract::Json<SyncRequest>,
-) -> Result<Json<SyncJobResponse>, StatusCode> {
-    let token = auth::extract_bearer_token(&headers)?;
-    let user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
-
-    let user_did = user_info.sub;
-    let slice_uri = request.slice;
-
-    match jobs::enqueue_sync_job(&state.database_pool, user_did, slice_uri, request.params).await {
-        Ok(job_id) => Ok(Json(SyncJobResponse {
-            success: true,
-            job_id: Some(job_id),
-            message: format!("Sync job {} enqueued successfully", job_id),
-        })),
-        Err(e) => {
-            tracing::error!("Failed to enqueue sync job: {}", e);
-            Ok(Json(SyncJobResponse {
-                success: false,
-                job_id: None,
-                message: format!("Failed to enqueue sync job: {}", e),
-            }))
-        }
-    }
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SyncUserCollectionsRequest {
-    pub slice: String,
-    #[serde(default = "default_timeout")]
-    pub timeout_seconds: u64,
-}
-
-fn default_timeout() -> u64 {
-    30
-}
-
-pub async fn sync_user_collections(
-    State(state): State<AppState>,
-    headers: HeaderMap,
-    Json(request): Json<SyncUserCollectionsRequest>,
-) -> Result<Json<crate::sync::SyncUserCollectionsResult>, (StatusCode, Json<serde_json::Value>)> {
-    let token = auth::extract_bearer_token(&headers).map_err(|e| {
-        (
-            StatusCode::UNAUTHORIZED,
-            Json(serde_json::json!({
-                "error": "AuthenticationRequired",
-                "message": format!("Bearer token required: {}", e)
-            })),
-        )
-    })?;
-
-    let user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url)
-        .await
-        .map_err(|e| {
-            (
-                StatusCode::UNAUTHORIZED,
-                Json(serde_json::json!({
-                    "error": "InvalidToken",
-                    "message": format!("Token verification failed: {}", e)
-                })),
-            )
-        })?;
-
-    let user_did = user_info.did.unwrap_or(user_info.sub);
-
-    info!(
-        "🔄 Starting user collections sync for {} on slice {} (timeout: {}s)",
-        user_did, request.slice, request.timeout_seconds
-    );
-
-    if request.timeout_seconds > 300 {
-        return Err((
-            StatusCode::BAD_REQUEST,
-            Json(serde_json::json!({
-                "error": "InvalidTimeout",
-                "message": "Maximum timeout is 300 seconds (5 minutes)"
-            })),
-        ));
-    }
-
-    let sync_service =
-        crate::sync::SyncService::new(state.database.clone(), state.config.relay_endpoint.clone());
-
-    match sync_service
-        .sync_user_collections(&user_did, &request.slice, request.timeout_seconds)
-        .await
-    {
-        Ok(result) => {
-            if result.timed_out {
-                info!(
-                    "⏰ Sync timed out for user {}, suggesting async job",
-                    user_did
-                );
-            } else {
-                info!(
-                    "✅ Sync completed for user {}: {} repos, {} records",
-                    user_did, result.repos_processed, result.records_synced
-                );
-            }
-            Ok(Json(result))
-        }
-        Err(e) => {
-            warn!("❌ Sync failed for user {}: {}", user_did, e);
-            Err((
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(serde_json::json!({
-                    "error": "SyncFailed",
-                    "message": format!("Sync operation failed: {}", e)
-                })),
-            ))
-        }
-    }
-}

api/src/api/upload_blob.rs

···
-use axum::{
-    extract::{State, Request},
-    http::StatusCode,
-    response::Json,
-};
-use serde::{Deserialize, Serialize};
-use crate::atproto_extensions::upload_blob as atproto_upload_blob;
-use axum::body::to_bytes;
-
-use crate::auth::{extract_bearer_token, verify_oauth_token, get_atproto_auth_for_user};
-use crate::AppState;
-
-// We need to use atproto-client's internal HTTP mechanism instead of manual DPoP
-// Let me try a different approach - use the same HTTP client that create_record uses
-
-#[derive(Serialize, Deserialize)]
-pub struct BlobRef {
-    #[serde(rename = "$type")]
-    pub blob_type: String,
-    pub r#ref: String,
-    #[serde(rename = "mimeType")]
-    pub mime_type: String,
-    pub size: u64,
-}
-
-// Handler for com.atproto.repo.uploadBlob
-pub async fn upload_blob(
-    State(state): State<AppState>,
-    request: Request,
-) -> Result<Json<serde_json::Value>, StatusCode> {
-
-    // Extract headers from the request
-    let headers = request.headers().clone();
-
-    // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers)?;
-    let _user_info = verify_oauth_token(&token, &state.config.auth_base_url).await?;
-
-    // Get AT Protocol DPoP auth and PDS URL
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url).await?;
-
-    // Get mime type from Content-Type header
-    let mime_type = headers
-        .get("content-type")
-        .and_then(|v| v.to_str().ok())
-        .unwrap_or("application/octet-stream")
-        .to_string();
-
-    // Extract binary data from request body
-    let body = request.into_body();
-    let blob_data = to_bytes(body, usize::MAX)
-        .await
-        .map_err(|_| StatusCode::BAD_REQUEST)?
-        .to_vec();
-
-    // Create HTTP client (same as dynamic handlers)
-    let http_client = reqwest::Client::new();
-
-    // Use our atproto extension that follows the same pattern as create_record, put_record, etc.
-    let upload_result = atproto_upload_blob(
-        &http_client,
-        &dpop_auth, 
-        &pds_url,
-        blob_data,
-        &mime_type
-    ).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-
-    // Convert to the expected JSON response format
-    let upload_response = serde_json::to_value(upload_result).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-
-    // Return the blob reference
-    Ok(Json(upload_response))
-}

api/src/api/xrpc_dynamic.rs

···
                 .collect();
 
             let output = SliceRecordsOutput {
-                success: true,
                 records: indexed_records,
                 cursor,
-                message: None,
             };
 
             Ok(Json(
···
                 .collect();
 
             let output = SliceRecordsOutput {
-                success: true,
                 records: indexed_records,
                 cursor,
-                message: None,
             };
 
             Ok(Json(serde_json::to_value(output).map_err(|_| {

api/src/atproto_extensions.rs

···
         .body(data)
         .send()
         .await
-        .map_err(|e| BlobUploadError::HttpRequest(e))?;
+        .map_err(BlobUploadError::HttpRequest)?;
 
     if !http_response.status().is_success() {
         let status = http_response.status();

api/src/auth.rs

···
     // Extract PDS URL from session
     let pds_url = session_data["pds_endpoint"]
         .as_str()
-        .ok_or_else(|| {
+        .ok_or({
             StatusCode::INTERNAL_SERVER_ERROR
         })?
         .to_string();
···
     // Extract AT Protocol access token from session data
     let atproto_access_token = session_data["access_token"]
         .as_str()
-        .ok_or_else(|| {
+        .ok_or({
             StatusCode::INTERNAL_SERVER_ERROR
         })?
         .to_string();

api/src/database.rs

···
 ) -> sqlx::query::QueryAs<'q, sqlx::Postgres, Record, sqlx::postgres::PgArguments> {
     if let Some(clause) = where_clause {
         // Bind AND condition parameters
-        for (_, condition) in &clause.conditions {
+        for condition in clause.conditions.values() {
             query_builder = bind_single_condition(query_builder, condition);
         }
 
         // Bind OR condition parameters
         if let Some(or_conditions) = &clause.or_conditions {
-            for (_, condition) in or_conditions {
+            for condition in or_conditions.values() {
                 query_builder = bind_single_condition(query_builder, condition);
             }
         }
···
                 .bind(&record.did)
                 .bind(&record.collection)
                 .bind(&record.json)
-                .bind(&record.indexed_at)
+                .bind(record.indexed_at)
                 .bind(&record.slice_uri);
         }
 
···
             .as_ref()
             .and_then(|wc| wc.conditions.get("collection"))
             .and_then(|c| c.eq.as_ref())
-            .and_then(|v| v.as_str())
-            .map_or(false, |s| s == "network.slices.lexicon");
+            .and_then(|v| v.as_str()) == Some("network.slices.lexicon");
 
         if is_lexicon {
             where_clauses.push(format!("json->>'slice' = ${}", param_count));
···
             .as_ref()
             .and_then(|wc| wc.conditions.get("collection"))
             .and_then(|c| c.eq.as_ref())
-            .and_then(|v| v.as_str())
-            .map_or(false, |s| s == "network.slices.lexicon");
+            .and_then(|v| v.as_str()) == Some("network.slices.lexicon");
 
         if is_lexicon {
             where_clauses.push(format!("json->>'slice' = ${}", param_count));
···
         // Bind where condition values using helper
         if let Some(clause) = where_clause {
             // Bind AND condition parameters
-            for (_, condition) in &clause.conditions {
+            for condition in clause.conditions.values() {
                 if let Some(eq_value) = &condition.eq {
                     if let Some(str_val) = eq_value.as_str() {
                         query_builder = query_builder.bind(str_val);
···
 
             // Bind OR condition parameters
             if let Some(or_conditions) = &clause.or_conditions {
-                for (_, condition) in or_conditions {
+                for condition in or_conditions.values() {
                     if let Some(eq_value) = &condition.eq {
                         if let Some(str_val) = eq_value.as_str() {
                             query_builder = query_builder.bind(str_val);
···
         .bind(&record.did)
         .bind(&record.collection)
         .bind(&record.json)
-        .bind(&record.indexed_at)
+        .bind(record.indexed_at)
         .bind(&record.slice_uri)
         .fetch_one(&self.pool)
         .await?;

api/src/errors.rs

···
 
     #[error("error-slices-app-6 Bad request: {0}")]
     BadRequest(String),
+
+    #[error("error-slices-app-7 Authentication required: {0}")]
+    AuthRequired(String),
+
+    #[error("error-slices-app-8 Forbidden: {0}")]
+    Forbidden(String),
+}
+
+impl From<StatusCode> for AppError {
+    fn from(status: StatusCode) -> Self {
+        match status {
+            StatusCode::BAD_REQUEST => AppError::BadRequest("Bad request".to_string()),
+            StatusCode::UNAUTHORIZED => AppError::AuthRequired("Authentication required".to_string()),
+            StatusCode::FORBIDDEN => AppError::Forbidden("Forbidden".to_string()),
+            StatusCode::NOT_FOUND => AppError::NotFound("Not found".to_string()),
+            _ => AppError::Internal(format!("HTTP error: {}", status)),
+        }
+    }
 }
 
 #[derive(Error, Debug)]
···
 
 impl IntoResponse for AppError {
     fn into_response(self) -> Response {
-        let (status, error_message) = match self {
-            AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg),
-            AppError::NotFound(msg) => (StatusCode::NOT_FOUND, msg),
-            AppError::Internal(msg) => (StatusCode::INTERNAL_SERVER_ERROR, msg),
-            AppError::DatabaseConnection(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
-            AppError::Migration(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
-            AppError::ServerBind(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
+        let (status, error_name, error_message) = match &self {
+            AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, "BadRequest", msg.clone()),
+            AppError::NotFound(msg) => (StatusCode::NOT_FOUND, "NotFound", msg.clone()),
+            AppError::AuthRequired(msg) => (StatusCode::UNAUTHORIZED, "AuthenticationRequired", msg.clone()),
+            AppError::Forbidden(msg) => (StatusCode::FORBIDDEN, "Forbidden", msg.clone()),
+            AppError::Internal(msg) => (StatusCode::INTERNAL_SERVER_ERROR, "InternalServerError", msg.clone()),
+            AppError::DatabaseConnection(e) => (StatusCode::INTERNAL_SERVER_ERROR, "InternalServerError", e.to_string()),
+            AppError::Migration(e) => (StatusCode::INTERNAL_SERVER_ERROR, "InternalServerError", e.to_string()),
+            AppError::ServerBind(e) => (StatusCode::INTERNAL_SERVER_ERROR, "InternalServerError", e.to_string()),
         };
 
         let body = Json(serde_json::json!({
-            "error": error_message
+            "error": error_name,
+            "message": error_message
         }));
 
         (status, body).into_response()

api/src/jetstream.rs

···
                                 "uri": uri,
                                 "rows_affected": rows_affected
                             })),
-                            Some(&slice_uri)
+                            Some(slice_uri)
                         );
                     }
 

api/src/jobs.rs

···
     );
     
     let collections_json = serde_json::to_value(&result.collections_synced)
-        .map_err(|e| sqlx::Error::Protocol(format!("Failed to serialize collections: {}", e).into()))?;
+        .map_err(|e| sqlx::Error::Protocol(format!("Failed to serialize collections: {}", e)))?;
 
     sqlx::query!(
         r#"

api/src/logging.rs

···
         for entry in batch.iter() {
             sqlx_query = sqlx_query
                 .bind(&entry.log_type)
-                .bind(&entry.job_id)
+                .bind(entry.job_id)
                 .bind(&entry.user_did)
                 .bind(&entry.slice_uri)
                 .bind(&entry.level)
                 .bind(&entry.message)
                 .bind(&entry.metadata)
-                .bind(&entry.created_at);
+                .bind(entry.created_at);
         }
         
         // Execute batch insert

api/src/main.rs

···
 mod logging;
 mod models;
 mod sync;
+mod xrpc;
 
 use axum::{
     Router,
···
 use std::sync::atomic::AtomicBool;
 use tower_http::{cors::CorsLayer, trace::TraceLayer};
 use tracing::info;
-use tracing_subscriber;
 
 use crate::database::Database;
 use crate::errors::AppError;
···
         // XRPC endpoints
         .route(
             "/xrpc/com.atproto.repo.uploadBlob",
-            post(api::upload_blob::upload_blob),
+            post(xrpc::com::atproto::repo::upload_blob::handler),
         )
         .route(
             "/xrpc/network.slices.slice.startSync",
-            post(api::sync::sync),
+            post(xrpc::network::slices::slice::start_sync::handler),
         )
         .route(
             "/xrpc/network.slices.slice.syncUserCollections",
-            post(api::sync::sync_user_collections),
+            post(xrpc::network::slices::slice::sync_user_collections::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getJobStatus",
-            get(api::jobs::get_job_status),
+            get(xrpc::network::slices::slice::get_job_status::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getJobHistory",
-            get(api::jobs::get_slice_job_history),
+            get(xrpc::network::slices::slice::get_job_history::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getJobLogs",
-            get(api::logs::get_sync_job_logs_handler),
+            get(xrpc::network::slices::slice::get_job_logs::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getJetstreamLogs",
-            get(api::logs::get_jetstream_logs_handler),
+            get(xrpc::network::slices::slice::get_jetstream_logs::handler),
         )
         .route(
             "/xrpc/network.slices.slice.stats",
-            post(api::stats::stats),
+            get(xrpc::network::slices::slice::stats::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getSparklines",
-            post(api::sparkline::batch_sparkline),
+            post(xrpc::network::slices::slice::get_sparklines::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getSliceRecords",
-            post(api::records::get_records),
+            post(xrpc::network::slices::slice::get_slice_records::handler),
         )
         .route(
             "/xrpc/network.slices.slice.openapi",
-            get(api::openapi::get_openapi_spec),
+            get(xrpc::network::slices::slice::openapi::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getJetstreamStatus",
-            get(api::jetstream::get_jetstream_status),
+            get(xrpc::network::slices::slice::get_jetstream_status::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getActors",
-            post(api::actors::get_actors),
+            post(xrpc::network::slices::slice::get_actors::handler),
         )
         .route(
             "/xrpc/network.slices.slice.createOAuthClient",
-            post(api::oauth::create_oauth_client),
+            post(xrpc::network::slices::slice::create_oauth_client::handler),
         )
         .route(
             "/xrpc/network.slices.slice.getOAuthClients",
-            get(api::oauth::get_oauth_clients),
+            get(xrpc::network::slices::slice::get_oauth_clients::handler),
         )
         .route(
             "/xrpc/network.slices.slice.updateOAuthClient",
-            post(api::oauth::update_oauth_client),
+            post(xrpc::network::slices::slice::update_oauth_client::handler),
         )
         .route(
             "/xrpc/network.slices.slice.deleteOAuthClient",
-            post(api::oauth::delete_oauth_client),
+            post(xrpc::network::slices::slice::delete_oauth_client::handler),
         )
         // Dynamic collection-specific XRPC endpoints (wildcard routes must come last)
         .route(

api/src/models.rs

···
     pub indexed_at: String,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ListRecordsOutput {
-    pub records: Vec<IndexedRecord>,
-    pub cursor: Option<String>,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BulkSyncParams {
···
     pub skip_validation: Option<bool>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BulkSyncOutput {
-    pub success: bool,
-    pub total_records: i64,
-    pub collections_synced: Vec<String>,
-    pub repos_processed: i64,
-    pub message: String,
-}
-
 #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
 #[serde(rename_all = "camelCase")]
 pub struct Actor {
···
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct SliceStatsParams {
-    pub slice: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SliceStatsOutput {
-    pub success: bool,
-    pub collections: Vec<String>,
-    pub collection_stats: Vec<CollectionStats>,
-    pub total_lexicons: i64,
-    pub total_records: i64,
-    pub total_actors: i64,
-    pub message: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 pub struct WhereCondition {
     pub eq: Option<Value>,
     #[serde(rename = "in")]
···
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SliceRecordsOutput {
-    pub success: bool,
     pub records: Vec<IndexedRecord>,
     pub cursor: Option<String>,
-    pub message: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
···
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct CreateOAuthClientRequest {
-    pub slice_uri: String,
-    pub client_name: String,
-    pub redirect_uris: Vec<String>,
-    pub grant_types: Option<Vec<String>>,
-    pub response_types: Option<Vec<String>>,
-    pub scope: Option<String>,
-    pub client_uri: Option<String>,
-    pub logo_uri: Option<String>,
-    pub tos_uri: Option<String>,
-    pub policy_uri: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct OAuthClientDetails {
-    pub client_id: String,
-    pub client_secret: Option<String>,
-    pub client_name: String,
-    pub redirect_uris: Vec<String>,
-    pub grant_types: Vec<String>,
-    pub response_types: Vec<String>,
-    pub scope: Option<String>,
-    pub client_uri: Option<String>,
-    pub logo_uri: Option<String>,
-    pub tos_uri: Option<String>,
-    pub policy_uri: Option<String>,
-    pub created_at: DateTime<Utc>,
-    pub created_by_did: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ListOAuthClientsResponse {
-    pub clients: Vec<OAuthClientDetails>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UpdateOAuthClientRequest {
-    pub client_id: String,
-    pub client_name: Option<String>,
-    pub redirect_uris: Option<Vec<String>>,
-    pub scope: Option<String>,
-    pub client_uri: Option<String>,
-    pub logo_uri: Option<String>,
-    pub tos_uri: Option<String>,
-    pub policy_uri: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DeleteOAuthClientResponse {
-    pub success: bool,
-    pub message: String,
-}
-
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
 pub struct SparklinePoint {
     pub timestamp: String, // ISO 8601
     pub count: i64,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetSparklinesParams {
-    pub slices: Vec<String>,
-    pub interval: Option<String>, // "hour", "day", "minute" - defaults to "hour"
-    pub duration: Option<String>, // "24h", "7d", "30d" - defaults to "24h"
-}
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GetSparklinesOutput {
-    pub success: bool,
-    pub sparklines: std::collections::HashMap<String, Vec<SparklinePoint>>,
-    pub message: Option<String>,
-}

api/src/sync.rs

···
                 for collection in &all_collections {
                     requests_by_pds
                         .entry(pds_url.clone())
-                        .or_insert_with(Vec::new)
+                        .or_default()
                         .push((repo.clone(), collection.clone()));
                 }
             }
···
 
             for atproto_record in list_response.records {
                 // Check if we already have this record with the same CID
-                if let Some(existing_cid) = existing_cids.get(&atproto_record.uri) {
-                    if existing_cid == &atproto_record.cid {
+                if let Some(existing_cid) = existing_cids.get(&atproto_record.uri)
+                    && existing_cid == &atproto_record.cid {
                         // Record unchanged, skip it
                         skipped_count += 1;
                         continue;
                     }
-                }
 
                 // Record is new or changed, include it
                 let record = Record {

api/src/xrpc/com/atproto/mod.rs

···
+pub mod repo;

api/src/xrpc/com/atproto/repo/mod.rs

···
+pub mod upload_blob;

api/src/xrpc/com/atproto/repo/upload_blob.rs

···
+use axum::{extract::{Request, State}, response::Json};
+use axum::body::to_bytes;
+use crate::{AppState, auth, atproto_extensions::upload_blob as atproto_upload_blob, errors::AppError};
+
+pub async fn handler(
+    State(state): State<AppState>,
+    request: Request,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let headers = request.headers().clone();
+
+    let token = auth::extract_bearer_token(&headers)?;
+    let _user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let (dpop_auth, pds_url) =
+        auth::get_atproto_auth_for_user(&token, &state.config.auth_base_url).await?;
+
+    let mime_type = headers
+        .get("content-type")
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("application/octet-stream")
+        .to_string();
+
+    let body = request.into_body();
+    let blob_data = to_bytes(body, usize::MAX)
+        .await
+        .map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?
+        .to_vec();
+
+    let http_client = reqwest::Client::new();
+
+    let upload_result = atproto_upload_blob(&http_client, &dpop_auth, &pds_url, blob_data, &mime_type)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to upload blob: {}", e)))?;
+
+    let upload_response = serde_json::to_value(upload_result)
+        .map_err(|e| AppError::Internal(format!("Failed to serialize response: {}", e)))?;
+
+    Ok(Json(upload_response))
+}

api/src/xrpc/com/mod.rs

···
+pub mod atproto;

api/src/xrpc/mod.rs

···
+pub mod com;
+pub mod network;

api/src/xrpc/network/mod.rs

···
+pub mod slices;

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

···
+pub mod slice;

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

···
+use axum::{extract::State, http::HeaderMap, response::Json};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use crate::{AppState, auth, errors::AppError};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice_uri: String,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Option<Vec<String>>,
+    pub response_types: Option<Vec<String>>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub client_id: String,
+    pub client_secret: Option<String>,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Vec<String>,
+    pub response_types: Vec<String>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub created_by_did: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+struct AipClientRequest {
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub grant_types: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_types: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub scope: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logo_uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tos_uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub policy_uri: Option<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+struct AipClientResponse {
+    pub client_id: String,
+    pub client_secret: Option<String>,
+    pub registration_access_token: Option<String>,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Vec<String>,
+    pub response_types: Vec<String>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    if params.client_name.trim().is_empty() {
+        return Err(AppError::BadRequest("Client name cannot be empty".to_string()));
+    }
+
+    if params.redirect_uris.is_empty() {
+        return Err(AppError::BadRequest(
+            "At least one redirect URI is required".to_string(),
+        ));
+    }
+
+    for uri in &params.redirect_uris {
+        if !uri.starts_with("http://") && !uri.starts_with("https://") {
+            return Err(AppError::BadRequest(format!(
+                "Redirect URI must use HTTP or HTTPS: {}",
+                uri
+            )));
+        }
+        if uri.trim().is_empty() {
+            return Err(AppError::BadRequest("Redirect URI cannot be empty".to_string()));
+        }
+    }
+
+    let token = auth::extract_bearer_token(&headers)?;
+    let user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let user_did = user_info.sub;
+
+    let client = Client::new();
+    let aip_request = AipClientRequest {
+        client_name: params.client_name.clone(),
+        redirect_uris: params.redirect_uris.clone(),
+        grant_types: params.grant_types.clone(),
+        response_types: params.response_types.clone(),
+        scope: params.scope.clone(),
+        client_uri: params.client_uri.clone(),
+        logo_uri: params.logo_uri.clone(),
+        tos_uri: params.tos_uri.clone(),
+        policy_uri: params.policy_uri.clone(),
+    };
+
+    let registration_url = format!("{}/oauth/clients/register", state.config.auth_base_url);
+
+    let aip_response = client
+        .post(&registration_url)
+        .json(&aip_request)
+        .send()
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to register client with AIP: {}", e)))?;
+
+    if !aip_response.status().is_success() {
+        let error_text = aip_response
+            .text()
+            .await
+            .unwrap_or_else(|_| "Unknown error".to_string());
+        return Err(AppError::Internal(format!(
+            "AIP registration failed: {}",
+            error_text
+        )));
+    }
+
+    let response_body = aip_response
+        .text()
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get response body: {}", e)))?;
+
+    let aip_client: AipClientResponse = serde_json::from_str(&response_body)
+        .map_err(|e| AppError::Internal(format!("Failed to parse AIP response: {}", e)))?;
+
+    let oauth_client = state
+        .database
+        .create_oauth_client(
+            &params.slice_uri,
+            &aip_client.client_id,
+            aip_client.registration_access_token.as_deref(),
+            &user_did,
+        )
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to store OAuth client: {}", e)))?;
+
+    Ok(Json(Output {
+        client_id: aip_client.client_id,
+        client_secret: aip_client.client_secret,
+        client_name: aip_client.client_name,
+        redirect_uris: aip_client.redirect_uris,
+        grant_types: aip_client.grant_types,
+        response_types: aip_client.response_types,
+        scope: aip_client.scope,
+        client_uri: aip_client.client_uri,
+        logo_uri: aip_client.logo_uri,
+        tos_uri: aip_client.tos_uri,
+        policy_uri: aip_client.policy_uri,
+        created_at: oauth_client.created_at,
+        created_by_did: oauth_client.created_by_did,
+    }))
+}

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

···
+use axum::{extract::State, http::HeaderMap, response::Json};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use crate::{AppState, auth, errors::AppError};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub client_id: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub message: String,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    let token = auth::extract_bearer_token(&headers)?;
+    auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let oauth_client = state
+        .database
+        .get_oauth_client_by_id(&params.client_id)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to fetch OAuth client: {}", e)))?
+        .ok_or_else(|| AppError::NotFound("OAuth client not found".to_string()))?;
+
+    if let Some(registration_token) = &oauth_client.registration_access_token {
+        let client = Client::new();
+        let _aip_response = client
+            .delete(format!(
+                "{}/oauth/clients/{}",
+                state.config.auth_base_url, params.client_id
+            ))
+            .bearer_auth(registration_token)
+            .send()
+            .await;
+    }
+
+    state
+        .database
+        .delete_oauth_client(&params.client_id)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to delete OAuth client: {}", e)))?;
+
+    Ok(Json(Output {
+        message: format!("OAuth client {} deleted successfully", params.client_id),
+    }))
+}

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

···
+use axum::{extract::State, response::Json};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use crate::{AppState, errors::AppError, models::{Actor, WhereCondition}};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: String,
+    pub limit: Option<i32>,
+    pub cursor: Option<String>,
+    #[serde(rename = "where")]
+    pub where_conditions: Option<HashMap<String, WhereCondition>>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub actors: Vec<Actor>,
+    pub cursor: Option<String>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    let (actors, cursor) = state
+        .database
+        .get_slice_actors(
+            &params.slice,
+            params.limit,
+            params.cursor.as_deref(),
+            params.where_conditions.as_ref(),
+        )
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to fetch actors: {}", e)))?;
+
+    Ok(Json(Output { actors, cursor }))
+}

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

···
+use axum::{extract::{Query, State}, response::Json};
+use serde::{Deserialize, Serialize};
+use crate::{AppState, errors::AppError, logging::{get_jetstream_logs, LogEntry}};
+
+#[derive(Debug, Deserialize)]
+pub struct Params {
+    pub limit: Option<i64>,
+    pub slice: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Output {
+    pub logs: Vec<LogEntry>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Query(params): Query<Params>,
+) -> Result<Json<Output>, AppError> {
+    let logs = get_jetstream_logs(&state.database_pool, params.slice.as_deref(), params.limit)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get jetstream logs: {}", e)))?;
+
+    Ok(Json(Output { logs }))
+}

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

···
+use axum::{extract::State, response::Json};
+use serde::Serialize;
+use crate::AppState;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub connected: bool,
+}
+
+pub async fn handler(State(state): State<AppState>) -> Json<Output> {
+    let connected = state
+        .jetstream_connected
+        .load(std::sync::atomic::Ordering::Relaxed);
+
+    Json(Output { connected })
+}

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

···
+use axum::{extract::{Query, State}, response::Json};
+use serde::Deserialize;
+use crate::{AppState, errors::AppError, jobs};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub user_did: String,
+    pub slice_uri: String,
+    pub limit: Option<i64>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Query(params): Query<Params>,
+) -> Result<Json<Vec<jobs::JobStatus>>, AppError> {
+    jobs::get_slice_job_history(
+        &state.database_pool,
+        &params.user_did,
+        &params.slice_uri,
+        params.limit,
+    )
+    .await
+    .map(Json)
+    .map_err(|e| AppError::Internal(format!("Failed to get slice job history: {}", e)))
+}

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

···
+use axum::{extract::{Query, State}, response::Json};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+use crate::{AppState, errors::AppError, logging::{get_sync_job_logs, LogEntry}};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub job_id: Uuid,
+    pub limit: Option<i64>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Output {
+    pub logs: Vec<LogEntry>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Query(params): Query<Params>,
+) -> Result<Json<Output>, AppError> {
+    let logs = get_sync_job_logs(&state.database_pool, params.job_id, params.limit)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get sync job logs: {}", e)))?;
+
+    Ok(Json(Output { logs }))
+}

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

···
+use axum::{extract::{Query, State}, response::Json};
+use serde::Deserialize;
+use uuid::Uuid;
+use crate::{AppState, errors::AppError, jobs};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub job_id: Uuid,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Query(params): Query<Params>,
+) -> Result<Json<jobs::JobStatus>, AppError> {
+    match jobs::get_job_status(&state.database_pool, params.job_id).await {
+        Ok(Some(status)) => Ok(Json(status)),
+        Ok(None) => Err(AppError::NotFound(format!("Job {} not found", params.job_id))),
+        Err(e) => Err(AppError::Internal(format!("Failed to get job status: {}", e))),
+    }
+}

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

···
+use axum::{extract::{Query, State}, http::HeaderMap, response::Json};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use crate::{AppState, auth, errors::AppError};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OAuthClientDetails {
+    pub client_id: String,
+    pub client_secret: Option<String>,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Vec<String>,
+    pub response_types: Vec<String>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub created_by_did: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub clients: Vec<OAuthClientDetails>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+struct AipClientResponse {
+    pub client_id: String,
+    pub client_secret: Option<String>,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Vec<String>,
+    pub response_types: Vec<String>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Query(params): Query<Params>,
+) -> Result<Json<Output>, AppError> {
+    let token = auth::extract_bearer_token(&headers)?;
+    auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let clients = state
+        .database
+        .get_oauth_clients_for_slice(&params.slice)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to fetch OAuth clients: {}", e)))?;
+
+    if clients.is_empty() {
+        return Ok(Json(Output { clients: vec![] }));
+    }
+
+    let aip_base_url = &state.config.auth_base_url;
+    let client = Client::new();
+    let mut client_details = Vec::new();
+
+    for oauth_client in clients {
+        let aip_url = format!("{}/oauth/clients/{}", aip_base_url, oauth_client.client_id);
+
+        let mut request_builder = client.get(&aip_url);
+        if let Some(token) = &oauth_client.registration_access_token {
+            request_builder = request_builder.bearer_auth(token);
+        }
+
+        match request_builder.send().await {
+            Ok(response) if response.status().is_success() => {
+                if let Ok(response_text) = response.text().await
+                    && let Ok(aip_client) = serde_json::from_str::<AipClientResponse>(&response_text) {
+                        client_details.push(OAuthClientDetails {
+                            client_id: aip_client.client_id,
+                            client_secret: aip_client.client_secret,
+                            client_name: aip_client.client_name,
+                            redirect_uris: aip_client.redirect_uris,
+                            grant_types: aip_client.grant_types,
+                            response_types: aip_client.response_types,
+                            scope: aip_client.scope,
+                            client_uri: aip_client.client_uri,
+                            logo_uri: aip_client.logo_uri,
+                            tos_uri: aip_client.tos_uri,
+                            policy_uri: aip_client.policy_uri,
+                            created_at: oauth_client.created_at,
+                            created_by_did: oauth_client.created_by_did,
+                        });
+                    }
+            }
+            _ => {
+                client_details.push(OAuthClientDetails {
+                    client_id: oauth_client.client_id,
+                    client_secret: None,
+                    client_name: "Unknown".to_string(),
+                    redirect_uris: vec![],
+                    grant_types: vec!["authorization_code".to_string()],
+                    response_types: vec!["code".to_string()],
+                    scope: None,
+                    client_uri: None,
+                    logo_uri: None,
+                    tos_uri: None,
+                    policy_uri: None,
+                    created_at: oauth_client.created_at,
+                    created_by_did: oauth_client.created_by_did,
+                });
+            }
+        }
+    }
+
+    Ok(Json(Output {
+        clients: client_details,
+    }))
+}

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

···
+use axum::{extract::State, response::Json};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use crate::{AppState, errors::AppError, models::{WhereClause, SortField}};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: String,
+    pub limit: Option<i32>,
+    pub cursor: Option<String>,
+    #[serde(rename = "where")]
+    pub where_clause: Option<WhereClause>,
+    pub sort_by: Option<Vec<SortField>>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IndexedRecord {
+    pub uri: String,
+    pub cid: String,
+    pub did: String,
+    pub collection: String,
+    pub value: Value,
+    pub indexed_at: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub records: Vec<IndexedRecord>,
+    pub cursor: Option<String>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    let (records, cursor) = state
+        .database
+        .get_slice_collections_records(
+            &params.slice,
+            params.limit,
+            params.cursor.as_deref(),
+            params.sort_by.as_ref(),
+            params.where_clause.as_ref(),
+        )
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get slice records: {}", e)))?;
+
+    let indexed_records: Vec<IndexedRecord> = records
+        .into_iter()
+        .map(|record| IndexedRecord {
+            uri: record.uri,
+            cid: record.cid,
+            did: record.did,
+            collection: record.collection,
+            value: record.json,
+            indexed_at: record.indexed_at.to_rfc3339(),
+        })
+        .collect();
+
+    Ok(Json(Output {
+        records: indexed_records,
+        cursor,
+    }))
+}

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

···
+use axum::{extract::State, response::Json};
+use serde::{Deserialize, Serialize};
+use crate::{AppState, errors::AppError, models::SparklinePoint};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slices: Vec<String>,
+    pub interval: Option<String>,
+    pub duration: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SparklineEntry {
+    pub slice_uri: String,
+    pub points: Vec<SparklinePoint>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub sparklines: Vec<SparklineEntry>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    let interval = params.interval.as_deref().unwrap_or("hour");
+    let duration = params.duration.as_deref().unwrap_or("24h");
+
+    let duration_hours = match duration {
+        "1h" => 1,
+        "24h" => 24,
+        "7d" => 24 * 7,
+        "30d" => 24 * 30,
+        _ => 24,
+    };
+
+    let sparklines_map = state
+        .database
+        .get_batch_sparkline_data(&params.slices, interval, duration_hours)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get sparkline data: {}", e)))?;
+
+    // Convert HashMap to array of SparklineEntry
+    let sparklines = sparklines_map
+        .into_iter()
+        .map(|(slice_uri, points)| SparklineEntry { slice_uri, points })
+        .collect();
+
+    Ok(Json(Output { sparklines }))
+}

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

···
+pub mod create_oauth_client;
+pub mod delete_oauth_client;
+pub mod get_actors;
+pub mod get_jetstream_logs;
+pub mod get_jetstream_status;
+pub mod get_job_history;
+pub mod get_job_logs;
+pub mod get_job_status;
+pub mod get_oauth_clients;
+pub mod get_slice_records;
+pub mod get_sparklines;
+pub mod openapi;
+pub mod start_sync;
+pub mod stats;
+pub mod sync_user_collections;
+pub mod update_oauth_client;

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

···
+pub use crate::api::openapi::get_openapi_spec as handler;

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

···
+use axum::{extract::State, http::HeaderMap, response::Json};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+use crate::{AppState, auth, errors::AppError, jobs, models::BulkSyncParams};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    #[serde(flatten)]
+    pub sync_params: BulkSyncParams,
+    pub slice: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub job_id: Uuid,
+    pub message: String,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    let token = auth::extract_bearer_token(&headers)?;
+    let user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let user_did = user_info.sub;
+    let slice_uri = params.slice;
+
+    let job_id = jobs::enqueue_sync_job(&state.database_pool, user_did, slice_uri.clone(), params.sync_params)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to enqueue sync job: {}", e)))?;
+
+    Ok(Json(Output {
+        job_id,
+        message: format!("Sync job {} enqueued successfully", job_id),
+    }))
+}

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

···
+use axum::{extract::{State, Query}, response::Json};
+use serde::{Deserialize, Serialize};
+use crate::{AppState, errors::AppError, models::CollectionStats};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub collections: Vec<String>,
+    pub collection_stats: Vec<CollectionStats>,
+    pub total_lexicons: i64,
+    pub total_records: i64,
+    pub total_actors: i64,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    Query(params): Query<Params>,
+) -> Result<Json<Output>, AppError> {
+    let (collections, collection_stats, total_lexicons, total_records, total_actors) = tokio::try_join!(
+        state.database.get_slice_collections_list(&params.slice),
+        state.database.get_slice_collection_stats(&params.slice),
+        state.database.get_slice_lexicon_count(&params.slice),
+        state.database.get_slice_total_records(&params.slice),
+        state.database.get_slice_total_actors(&params.slice),
+    )
+    .map_err(|e| AppError::Internal(format!("Failed to get slice statistics: {}", e)))?;
+
+    Ok(Json(Output {
+        collections,
+        collection_stats: collection_stats
+            .into_iter()
+            .map(|cs| CollectionStats {
+                collection: cs.collection,
+                record_count: cs.record_count,
+                unique_actors: cs.unique_actors,
+            })
+            .collect(),
+        total_lexicons,
+        total_records,
+        total_actors,
+    }))
+}

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

···
+use axum::{extract::State, http::HeaderMap, response::Json};
+use serde::Deserialize;
+use crate::{AppState, auth, errors::AppError};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: String,
+    #[serde(default = "default_timeout")]
+    pub timeout_seconds: u64,
+}
+
+fn default_timeout() -> u64 {
+    30
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(params): Json<Params>,
+) -> Result<Json<crate::sync::SyncUserCollectionsResult>, AppError> {
+    let token = auth::extract_bearer_token(&headers)?;
+    let user_info = auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let user_did = user_info.did.unwrap_or(user_info.sub);
+
+    if params.timeout_seconds > 300 {
+        return Err(AppError::BadRequest(
+            "Maximum timeout is 300 seconds (5 minutes)".to_string(),
+        ));
+    }
+
+    tracing::info!(
+        "🔄 Starting user collections sync for {} on slice {} (timeout: {}s)",
+        user_did,
+        params.slice,
+        params.timeout_seconds
+    );
+
+    let sync_service =
+        crate::sync::SyncService::new(state.database.clone(), state.config.relay_endpoint.clone());
+
+    let result = sync_service
+        .sync_user_collections(&user_did, &params.slice, params.timeout_seconds)
+        .await
+        .map_err(|e| AppError::Internal(format!("Sync operation failed: {}", e)))?;
+
+    if result.timed_out {
+        tracing::info!("⏰ Sync timed out for user {}, suggesting async job", user_did);
+    } else {
+        tracing::info!(
+            "✅ Sync completed for user {}: {} repos, {} records",
+            user_did,
+            result.repos_processed,
+            result.records_synced
+        );
+    }
+
+    Ok(Json(result))
+}

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

···
+use axum::{extract::State, http::HeaderMap, response::Json};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use crate::{AppState, auth, errors::AppError};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub client_id: String,
+    pub client_name: Option<String>,
+    pub redirect_uris: Option<Vec<String>>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Output {
+    pub client_id: String,
+    pub client_secret: Option<String>,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Vec<String>,
+    pub response_types: Vec<String>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub created_by_did: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "snake_case")]
+struct AipClientRequest {
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub scope: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub client_uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logo_uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tos_uri: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub policy_uri: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "snake_case")]
+struct AipClientResponse {
+    pub client_id: String,
+    pub client_secret: Option<String>,
+    pub client_name: String,
+    pub redirect_uris: Vec<String>,
+    pub grant_types: Vec<String>,
+    pub response_types: Vec<String>,
+    pub scope: Option<String>,
+    pub client_uri: Option<String>,
+    pub logo_uri: Option<String>,
+    pub tos_uri: Option<String>,
+    pub policy_uri: Option<String>,
+}
+
+pub async fn handler(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(params): Json<Params>,
+) -> Result<Json<Output>, AppError> {
+    let token = auth::extract_bearer_token(&headers)?;
+    auth::verify_oauth_token(&token, &state.config.auth_base_url).await?;
+
+    let oauth_client = state
+        .database
+        .get_oauth_client_by_id(&params.client_id)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to fetch OAuth client: {}", e)))?
+        .ok_or_else(|| AppError::NotFound("OAuth client not found".to_string()))?;
+
+    let registration_token = oauth_client
+        .registration_access_token
+        .ok_or_else(|| AppError::Internal("Client missing registration access token".to_string()))?;
+
+    let aip_request = AipClientRequest {
+        client_name: params.client_name.unwrap_or_default(),
+        redirect_uris: params.redirect_uris.unwrap_or_default(),
+        scope: params.scope,
+        client_uri: params.client_uri,
+        logo_uri: params.logo_uri,
+        tos_uri: params.tos_uri,
+        policy_uri: params.policy_uri,
+    };
+
+    let client = Client::new();
+    let update_url = format!(
+        "{}/oauth/clients/{}",
+        state.config.auth_base_url, params.client_id
+    );
+
+    let aip_response = client
+        .put(&update_url)
+        .bearer_auth(&registration_token)
+        .json(&aip_request)
+        .send()
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to update client with AIP: {}", e)))?;
+
+    if !aip_response.status().is_success() {
+        let error_text = aip_response
+            .text()
+            .await
+            .unwrap_or_else(|_| "Unknown error".to_string());
+        return Err(AppError::Internal(format!("AIP update failed: {}", error_text)));
+    }
+
+    let response_body = aip_response
+        .text()
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to get response body: {}", e)))?;
+
+    let aip_client: AipClientResponse = serde_json::from_str(&response_body)
+        .map_err(|e| AppError::Internal(format!("Failed to parse AIP response: {}", e)))?;
+
+    Ok(Json(Output {
+        client_id: aip_client.client_id,
+        client_secret: aip_client.client_secret,
+        client_name: aip_client.client_name,
+        redirect_uris: aip_client.redirect_uris,
+        grant_types: aip_client.grant_types,
+        response_types: aip_client.response_types,
+        scope: aip_client.scope,
+        client_uri: aip_client.client_uri,
+        logo_uri: aip_client.logo_uri,
+        tos_uri: aip_client.tos_uri,
+        policy_uri: aip_client.policy_uri,
+        created_at: oauth_client.created_at,
+        created_by_did: oauth_client.created_by_did,
+    }))
+}

deno.lock

···
   "version": "5",
   "specifiers": {
     "jsr:@shikijs/shiki@^3.7.0": "3.7.0",
+    "jsr:@std/assert@*": "1.0.14",
+    "jsr:@std/cli@^1.0.21": "1.0.22",
+    "jsr:@std/cli@^1.0.22": "1.0.22",
+    "jsr:@std/encoding@^1.0.10": "1.0.10",
+    "jsr:@std/fmt@^1.0.2": "1.0.8",
+    "jsr:@std/fmt@^1.0.8": "1.0.8",
+    "jsr:@std/fs@^1.0.19": "1.0.19",
+    "jsr:@std/fs@^1.0.4": "1.0.19",
+    "jsr:@std/html@^1.0.4": "1.0.4",
+    "jsr:@std/http@^1.0.17": "1.0.20",
+    "jsr:@std/internal@^1.0.10": "1.0.10",
+    "jsr:@std/internal@^1.0.9": "1.0.10",
+    "jsr:@std/media-types@^1.1.0": "1.1.0",
+    "jsr:@std/net@^1.0.4": "1.0.6",
+    "jsr:@std/path@^1.0.6": "1.1.2",
+    "jsr:@std/path@^1.1.1": "1.1.2",
+    "jsr:@std/streams@^1.0.10": "1.0.12",
     "npm:@shikijs/core@^3.7.0": "3.13.0",
     "npm:@shikijs/engine-oniguruma@^3.7.0": "3.13.0",
     "npm:@shikijs/types@^3.7.0": "3.13.0",
···
         "npm:@shikijs/types",
         "npm:shiki"
       ]
+    },
+    "@std/assert@1.0.14": {
+      "integrity": "68d0d4a43b365abc927f45a9b85c639ea18a9fab96ad92281e493e4ed84abaa4",
+      "dependencies": [
+        "jsr:@std/internal@^1.0.10"
+      ]
+    },
+    "@std/cli@1.0.22": {
+      "integrity": "50d1e4f87887cb8a8afa29b88505ab5081188f5cad3985460c3b471fa49ff21a"
+    },
+    "@std/encoding@1.0.10": {
+      "integrity": "8783c6384a2d13abd5e9e87a7ae0520a30e9f56aeeaa3bdf910a3eaaf5c811a1"
+    },
+    "@std/fmt@1.0.8": {
+      "integrity": "71e1fc498787e4434d213647a6e43e794af4fd393ef8f52062246e06f7e372b7"
+    },
+    "@std/fs@1.0.19": {
+      "integrity": "051968c2b1eae4d2ea9f79a08a3845740ef6af10356aff43d3e2ef11ed09fb06",
+      "dependencies": [
+        "jsr:@std/internal@^1.0.9",
+        "jsr:@std/path@^1.1.1"
+      ]
+    },
+    "@std/html@1.0.4": {
+      "integrity": "eff3497c08164e6ada49b7f81a28b5108087033823153d065e3f89467dd3d50e"
+    },
+    "@std/http@1.0.20": {
+      "integrity": "b5cc33fc001bccce65ed4c51815668c9891c69ccd908295997e983d8f56070a1",
+      "dependencies": [
+        "jsr:@std/cli@^1.0.21",
+        "jsr:@std/encoding",
+        "jsr:@std/fmt@^1.0.8",
+        "jsr:@std/fs@^1.0.19",
+        "jsr:@std/html",
+        "jsr:@std/media-types",
+        "jsr:@std/net",
+        "jsr:@std/path@^1.1.1",
+        "jsr:@std/streams"
+      ]
+    },
+    "@std/internal@1.0.10": {
+      "integrity": "e3be62ce42cab0e177c27698e5d9800122f67b766a0bea6ca4867886cbde8cf7"
+    },
+    "@std/media-types@1.1.0": {
+      "integrity": "c9d093f0c05c3512932b330e3cc1fe1d627b301db33a4c2c2185c02471d6eaa4"
+    },
+    "@std/net@1.0.6": {
+      "integrity": "110735f93e95bb9feb95790a8b1d1bf69ec0dc74f3f97a00a76ea5efea25500c"
+    },
+    "@std/path@1.1.2": {
+      "integrity": "c0b13b97dfe06546d5e16bf3966b1cadf92e1cc83e56ba5476ad8b498d9e3038",
+      "dependencies": [
+        "jsr:@std/internal@^1.0.10"
+      ]
+    },
+    "@std/streams@1.0.12": {
+      "integrity": "ae925fa1dc459b1abf5cbaa28cc5c7b0485853af3b2a384b0dc22d86e59dfbf4"
     }
   },
   "npm": {

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-24 17:50:48 UTC
-// Lexicons: 25
+// Generated at: 2025-09-26 18:40:59 UTC
+// Lexicons: 40
 
 /**
  * @example Usage
···
   type AuthProvider,
   type BlobRef,
   type CountRecordsResponse,
-  type GetActorsParams,
-  type GetActorsResponse,
   type GetRecordParams,
   type GetRecordsResponse,
   type IndexedRecordFields,
   type RecordResponse,
-  type SliceLevelRecordsParams,
-  type SliceRecordsOutput,
   SlicesClient,
   type SortField,
   type WhereCondition,
 } from "@slices/client";
 import type { OAuthClient } from "@slices/oauth";
-
-export interface BulkSyncParams {
-  collections?: string[];
-  externalCollections?: string[];
-  repos?: string[];
-  limitPerRepo?: number;
-}
-
-export interface BulkSyncOutput {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-export interface SyncJobResponse {
-  success: boolean;
-  jobId?: string;
-  message: string;
-}
-
-export interface SyncJobResult {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-export interface JobStatus {
-  jobId: string;
-  status: string;
-  createdAt: string;
-  startedAt?: string;
-  completedAt?: string;
-  result?: SyncJobResult;
-  error?: string;
-  retryCount: number;
-}
-
-export interface GetJobStatusParams {
-  jobId: string;
-}
-
-export interface GetJobHistoryParams {
-  userDid: string;
-  sliceUri: string;
-  limit?: number;
-}
-
-export type GetJobHistoryResponse = JobStatus[];
-
-export interface GetJobLogsParams {
-  jobId: string;
-  limit?: number;
-}
-
-export interface GetJobLogsResponse {
-  logs: LogEntry[];
-}
-
-export interface GetJetstreamLogsParams {
-  limit?: number;
-}
-
-export interface GetJetstreamLogsResponse {
-  logs: LogEntry[];
-}
-
-export interface LogEntry {
-  id: number;
-  createdAt: string;
-  logType: string;
-  jobId?: string;
-  userDid?: string;
-  sliceUri?: string;
-  level: string;
-  message: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface SyncUserCollectionsRequest {
-  slice: string;
-  timeoutSeconds?: number;
-}
-
-export interface SyncUserCollectionsResult {
-  success: boolean;
-  reposProcessed: number;
-  recordsSynced: number;
-  timedOut: boolean;
-  message: string;
-}
-
-export interface JetstreamStatusResponse {
-  connected: boolean;
-  status: string;
-  error?: string;
-}
-
-export interface CollectionStats {
-  collection: string;
-  recordCount: number;
-  uniqueActors: number;
-}
-
-export interface SliceStatsParams {
-  slice: string;
-}
-
-export interface SliceStatsOutput {
-  success: boolean;
-  collections: string[];
-  collectionStats: CollectionStats[];
-  totalLexicons: number;
-  totalRecords: number;
-  totalActors: number;
-  message?: string;
-}
-
-export interface GetSparklinesParams {
-  slices: string[];
-  interval?: string;
-  duration?: string;
-}
-
-export interface GetSparklinesOutput {
-  success: boolean;
-  sparklines: Record<string, NetworkSlicesSliceDefs["SparklinePoint"][]>;
-  message?: string;
-}
-
-export interface CreateOAuthClientRequest {
-  clientName: string;
-  redirectUris: string[];
-  grantTypes?: string[];
-  responseTypes?: string[];
-  scope?: string;
-  clientUri?: string;
-  logoUri?: string;
-  tosUri?: string;
-  policyUri?: string;
-}
-
-export interface OAuthClientDetails {
-  clientId: string;
-  clientSecret?: string;
-  clientName: string;
-  redirectUris: string[];
-  grantTypes: string[];
-  responseTypes: string[];
-  scope?: string;
-  clientUri?: string;
-  logoUri?: string;
-  tosUri?: string;
-  policyUri?: string;
-  createdAt: string;
-  createdByDid: string;
-}
-
-export interface ListOAuthClientsResponse {
-  clients: OAuthClientDetails[];
-}
-
-export interface UpdateOAuthClientRequest {
-  clientId: string;
-  clientName?: string;
-  redirectUris?: string[];
-  scope?: string;
-  clientUri?: string;
-  logoUri?: string;
-  tosUri?: string;
-  policyUri?: string;
-}
-
-export interface DeleteOAuthClientResponse {
-  success: boolean;
-  message: string;
-}
-
-export interface OAuthOperationError {
-  success: false;
-  message: string;
-}
 
 export type AppBskyGraphDefsListPurpose =
   | "app.bsky.graph.defs#modlist"
···
   | "createdAt"
   | "expiresAt";
 
+export interface NetworkSlicesSliceSyncUserCollectionsInput {
+  slice: string;
+  timeoutSeconds?: number;
+}
+
+export interface NetworkSlicesSliceSyncUserCollectionsOutput {
+  reposProcessed: number;
+  recordsSynced: number;
+  timedOut: boolean;
+}
+
 export interface NetworkSlicesSliceDefsSliceView {
   uri: string;
   cid: string;
···
   count: number;
 }
 
+export interface NetworkSlicesSliceGetSparklinesInput {
+  slices: string[];
+  interval?: string;
+  duration?: string;
+}
+
+export interface NetworkSlicesSliceGetSparklinesOutput {
+  sparklines: NetworkSlicesSliceGetSparklines["SparklineEntry"][];
+}
+
+export interface NetworkSlicesSliceGetSparklinesSparklineEntry {
+  /** AT-URI of the slice */
+  sliceUri: string;
+  /** Array of sparkline data points */
+  points: NetworkSlicesSliceDefs["SparklinePoint"][];
+}
+
+export interface NetworkSlicesSliceGetJobLogsParams {
+  jobId: string;
+  limit?: number;
+}
+
+export interface NetworkSlicesSliceGetJobLogsOutput {
+  logs: NetworkSlicesSliceGetJobLogs["LogEntry"][];
+}
+
+export interface NetworkSlicesSliceGetJobLogsLogEntry {
+  /** Log entry ID */
+  id: number;
+  /** When the log entry was created */
+  createdAt: string;
+  /** Type of log entry */
+  logType: string;
+  /** UUID of related job if applicable */
+  jobId?: string;
+  /** DID of related user if applicable */
+  userDid?: string;
+  /** AT-URI of related slice if applicable */
+  sliceUri?: string;
+  /** Log level */
+  level: string;
+  /** Log message */
+  message: string;
+  /** Additional metadata associated with the log entry */
+  metadata?: unknown;
+}
+
+export interface NetworkSlicesSliceGetJetstreamStatusOutput {
+  connected: boolean;
+}
+
 export interface NetworkSlicesSlice {
   /** Name of the slice */
   name: string;
···
 
 export type NetworkSlicesSliceSortFields = "name" | "domain" | "createdAt";
 
+export interface NetworkSlicesSliceGetJobStatusParams {
+  jobId: string;
+}
+
+export type NetworkSlicesSliceGetJobStatusOutput =
+  NetworkSlicesSliceGetJobStatus["JobStatus"];
+
+export interface NetworkSlicesSliceGetJobStatusJobStatus {
+  /** UUID of the job */
+  jobId: string;
+  /** Current status of the job */
+  status: string;
+  /** When the job was created */
+  createdAt: string;
+  /** When the job started executing */
+  startedAt?: string;
+  /** When the job completed */
+  completedAt?: string;
+  /** Job result if completed successfully */
+  result?: NetworkSlicesSliceGetJobStatus["SyncJobResult"];
+  /** Error message if job failed */
+  error?: string;
+  /** Number of times the job has been retried */
+  retryCount: number;
+}
+
+export interface NetworkSlicesSliceGetJobStatusSyncJobResult {
+  /** Whether the sync job completed successfully */
+  success: boolean;
+  /** Total number of records synced */
+  totalRecords: number;
+  /** List of collection NSIDs that were synced */
+  collectionsSynced: string[];
+  /** Number of repositories processed */
+  reposProcessed: number;
+  /** Human-readable message about the job completion */
+  message: string;
+}
+
+export interface NetworkSlicesSliceGetActorsInput {
+  slice: string;
+  limit?: number;
+  cursor?: string;
+  where?: unknown;
+}
+
+export interface NetworkSlicesSliceGetActorsOutput {
+  actors: NetworkSlicesSliceGetActors["Actor"][];
+  cursor?: string;
+}
+
+export interface NetworkSlicesSliceGetActorsActor {
+  /** Decentralized identifier of the actor */
+  did: string;
+  /** Human-readable handle of the actor */
+  handle?: string;
+  /** AT-URI of the slice this actor is indexed in */
+  sliceUri: string;
+  /** When this actor was indexed */
+  indexedAt: string;
+}
+
+export interface NetworkSlicesSliceDeleteOAuthClientInput {
+  clientId: string;
+}
+
+export interface NetworkSlicesSliceDeleteOAuthClientOutput {
+  message: string;
+}
+
+export interface NetworkSlicesSliceCreateOAuthClientInput {
+  sliceUri: string;
+  clientName: string;
+  redirectUris: string[];
+  grantTypes?: string[];
+  responseTypes?: string[];
+  scope?: string;
+  clientUri?: string;
+  logoUri?: string;
+  tosUri?: string;
+  policyUri?: string;
+}
+
+export type NetworkSlicesSliceCreateOAuthClientOutput =
+  NetworkSlicesSliceGetOAuthClients["OauthClientDetails"];
+
+export interface NetworkSlicesSliceGetJetstreamLogsParams {
+  slice?: string;
+  limit?: number;
+}
+
+export interface NetworkSlicesSliceGetJetstreamLogsOutput {
+  logs: NetworkSlicesSliceGetJobLogs["LogEntry"][];
+}
+
+export interface NetworkSlicesSliceGetSliceRecordsInput {
+  slice: string;
+  limit?: number;
+  cursor?: string;
+  where?: unknown;
+  sortBy?: unknown;
+}
+
+export interface NetworkSlicesSliceGetSliceRecordsOutput {
+  records: NetworkSlicesSliceGetSliceRecords["IndexedRecord"][];
+  cursor?: string;
+}
+
+export interface NetworkSlicesSliceGetSliceRecordsIndexedRecord {
+  /** AT-URI of the record */
+  uri: string;
+  /** Content identifier of the record */
+  cid: string;
+  /** DID of the record creator */
+  did: string;
+  /** NSID of the collection this record belongs to */
+  collection: string;
+  /** The record value/content */
+  value: unknown;
+  /** When this record was indexed */
+  indexedAt: string;
+}
+
+export interface NetworkSlicesSliceStartSyncInput {
+  slice: string;
+  collections?: string[];
+  externalCollections?: string[];
+  repos?: string[];
+  limitPerRepo?: number;
+  skipValidation?: boolean;
+}
+
+export interface NetworkSlicesSliceStartSyncOutput {
+  jobId: string;
+  message: string;
+}
+
+export interface NetworkSlicesSliceGetJobHistoryParams {
+  userDid: string;
+  sliceUri: string;
+  limit?: number;
+}
+
+export type NetworkSlicesSliceGetJobHistoryOutput =
+  NetworkSlicesSliceGetJobStatus["JobStatus"][];
+
+export interface NetworkSlicesSliceStatsParams {
+  slice: string;
+}
+
+export interface NetworkSlicesSliceStatsOutput {
+  collections: string[];
+  collectionStats: NetworkSlicesSliceStats["CollectionStats"][];
+  totalLexicons: number;
+  totalRecords: number;
+  totalActors: number;
+}
+
+export interface NetworkSlicesSliceStatsCollectionStats {
+  /** Collection NSID */
+  collection: string;
+  /** Number of records in this collection */
+  recordCount: number;
+  /** Number of unique actors with records in this collection */
+  uniqueActors: number;
+}
+
+export interface NetworkSlicesSliceUpdateOAuthClientInput {
+  clientId: string;
+  clientName?: string;
+  redirectUris?: string[];
+  scope?: string;
+  clientUri?: string;
+  logoUri?: string;
+  tosUri?: string;
+  policyUri?: string;
+}
+
+export type NetworkSlicesSliceUpdateOAuthClientOutput =
+  NetworkSlicesSliceGetOAuthClients["OauthClientDetails"];
+
+export interface NetworkSlicesSliceGetOAuthClientsParams {
+  slice: string;
+}
+
+export interface NetworkSlicesSliceGetOAuthClientsOutput {
+  clients: NetworkSlicesSliceGetOAuthClients["OauthClientDetails"][];
+}
+
+export interface NetworkSlicesSliceGetOAuthClientsOauthClientDetails {
+  /** OAuth client ID */
+  clientId: string;
+  /** OAuth client secret (only returned on creation) */
+  clientSecret?: string;
+  /** Human-readable name of the OAuth client */
+  clientName: string;
+  /** Allowed redirect URIs for OAuth flow */
+  redirectUris: string[];
+  /** Allowed OAuth grant types */
+  grantTypes: string[];
+  /** Allowed OAuth response types */
+  responseTypes: string[];
+  /** OAuth scope */
+  scope?: string;
+  /** URI of the client application */
+  clientUri?: string;
+  /** URI of the client logo */
+  logoUri?: string;
+  /** URI of the terms of service */
+  tosUri?: string;
+  /** URI of the privacy policy */
+  policyUri?: string;
+  /** When the OAuth client was created */
+  createdAt: string;
+  /** DID of the user who created this client */
+  createdByDid: string;
+}
+
 export interface NetworkSlicesLexicon {
   /** Namespaced identifier for the lexicon */
   nsid: string;
···
 export interface NetworkSlicesSliceDefs {
   readonly SliceView: NetworkSlicesSliceDefsSliceView;
   readonly SparklinePoint: NetworkSlicesSliceDefsSparklinePoint;
+}
+
+export interface NetworkSlicesSliceGetSparklines {
+  readonly SparklineEntry: NetworkSlicesSliceGetSparklinesSparklineEntry;
+}
+
+export interface NetworkSlicesSliceGetJobLogs {
+  readonly LogEntry: NetworkSlicesSliceGetJobLogsLogEntry;
+}
+
+export interface NetworkSlicesSliceGetJobStatus {
+  readonly JobStatus: NetworkSlicesSliceGetJobStatusJobStatus;
+  readonly SyncJobResult: NetworkSlicesSliceGetJobStatusSyncJobResult;
+}
+
+export interface NetworkSlicesSliceGetActors {
+  readonly Actor: NetworkSlicesSliceGetActorsActor;
+}
+
+export interface NetworkSlicesSliceGetSliceRecords {
+  readonly IndexedRecord: NetworkSlicesSliceGetSliceRecordsIndexedRecord;
+}
+
+export interface NetworkSlicesSliceStats {
+  readonly CollectionStats: NetworkSlicesSliceStatsCollectionStats;
+}
+
+export interface NetworkSlicesSliceGetOAuthClients {
+  readonly OauthClientDetails:
+    NetworkSlicesSliceGetOAuthClientsOauthClientDetails;
 }
 
 export interface NetworkSlicesActorDefs {
···
     return await this.client.deleteRecord("network.slices.slice", rkey);
   }
 
-  async stats(params: SliceStatsParams): Promise<SliceStatsOutput> {
-    return await this.client.makeRequest<SliceStatsOutput>(
-      "network.slices.slice.stats",
-      "POST",
-      params,
-    );
+  async syncUserCollections(
+    input: NetworkSlicesSliceSyncUserCollectionsInput,
+  ): Promise<NetworkSlicesSliceSyncUserCollectionsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceSyncUserCollectionsOutput
+    >("network.slices.slice.syncUserCollections", "POST", input);
   }
 
   async getSparklines(
-    params: GetSparklinesParams,
-  ): Promise<GetSparklinesOutput> {
-    return await this.client.makeRequest<GetSparklinesOutput>(
+    input: NetworkSlicesSliceGetSparklinesInput,
+  ): Promise<NetworkSlicesSliceGetSparklinesOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetSparklinesOutput>(
       "network.slices.slice.getSparklines",
       "POST",
-      params,
+      input,
     );
   }
 
-  async getSliceRecords<T = Record<string, unknown>>(
-    params: Omit<SliceLevelRecordsParams<T>, "slice">,
-  ): Promise<SliceRecordsOutput<T>> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: Record<string, unknown> = params?.where
-      ? { ...params.where }
-      : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.client.sliceUri,
-    };
-    return await this.client.makeRequest<SliceRecordsOutput<T>>(
-      "network.slices.slice.getSliceRecords",
-      "POST",
-      requestParams,
-    );
-  }
-
-  async getActors(params?: GetActorsParams): Promise<GetActorsResponse> {
-    const requestParams = { ...params, slice: this.client.sliceUri };
-    return await this.client.makeRequest<GetActorsResponse>(
-      "network.slices.slice.getActors",
-      "POST",
-      requestParams,
+  async getJobLogs(
+    params?: NetworkSlicesSliceGetJobLogsParams,
+  ): Promise<NetworkSlicesSliceGetJobLogsOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetJobLogsOutput>(
+      "network.slices.slice.getJobLogs",
+      "GET",
+      params,
     );
   }
 
-  async startSync(params: BulkSyncParams): Promise<SyncJobResponse> {
-    const requestParams = { ...params, slice: this.client.sliceUri };
-    return await this.client.makeRequest<SyncJobResponse>(
-      "network.slices.slice.startSync",
-      "POST",
-      requestParams,
-    );
+  async getJetstreamStatus(): Promise<
+    NetworkSlicesSliceGetJetstreamStatusOutput
+  > {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetJetstreamStatusOutput
+    >("network.slices.slice.getJetstreamStatus", "GET", {});
   }
 
-  async getJobStatus(params: GetJobStatusParams): Promise<JobStatus> {
-    return await this.client.makeRequest<JobStatus>(
+  async getJobStatus(
+    params?: NetworkSlicesSliceGetJobStatusParams,
+  ): Promise<NetworkSlicesSliceGetJobStatusOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetJobStatusOutput>(
       "network.slices.slice.getJobStatus",
       "GET",
       params,
     );
   }
 
-  async getJobHistory(
-    params: GetJobHistoryParams,
-  ): Promise<GetJobHistoryResponse> {
-    return await this.client.makeRequest<GetJobHistoryResponse>(
-      "network.slices.slice.getJobHistory",
-      "GET",
-      params,
+  async getActors(
+    input: NetworkSlicesSliceGetActorsInput,
+  ): Promise<NetworkSlicesSliceGetActorsOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetActorsOutput>(
+      "network.slices.slice.getActors",
+      "POST",
+      input,
     );
   }
 
-  async getJobLogs(params: GetJobLogsParams): Promise<GetJobLogsResponse> {
-    return await this.client.makeRequest<GetJobLogsResponse>(
-      "network.slices.slice.getJobLogs",
-      "GET",
-      params,
-    );
+  async deleteOAuthClient(
+    input: NetworkSlicesSliceDeleteOAuthClientInput,
+  ): Promise<NetworkSlicesSliceDeleteOAuthClientOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceDeleteOAuthClientOutput
+    >("network.slices.slice.deleteOAuthClient", "POST", input);
   }
 
-  async getJetstreamStatus(): Promise<JetstreamStatusResponse> {
-    return await this.client.makeRequest<JetstreamStatusResponse>(
-      "network.slices.slice.getJetstreamStatus",
-      "GET",
-    );
+  async createOAuthClient(
+    input: NetworkSlicesSliceCreateOAuthClientInput,
+  ): Promise<NetworkSlicesSliceCreateOAuthClientOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceCreateOAuthClientOutput
+    >("network.slices.slice.createOAuthClient", "POST", input);
   }
 
   async getJetstreamLogs(
-    params: GetJetstreamLogsParams,
-  ): Promise<GetJetstreamLogsResponse> {
-    const requestParams = { ...params, slice: this.client.sliceUri };
-    return await this.client.makeRequest<GetJetstreamLogsResponse>(
-      "network.slices.slice.getJetstreamLogs",
-      "GET",
-      requestParams,
-    );
+    params?: NetworkSlicesSliceGetJetstreamLogsParams,
+  ): Promise<NetworkSlicesSliceGetJetstreamLogsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetJetstreamLogsOutput
+    >("network.slices.slice.getJetstreamLogs", "GET", params);
+  }
+
+  async getSliceRecords(
+    input: NetworkSlicesSliceGetSliceRecordsInput,
+  ): Promise<NetworkSlicesSliceGetSliceRecordsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetSliceRecordsOutput
+    >("network.slices.slice.getSliceRecords", "POST", input);
   }
 
-  async syncUserCollections(
-    params?: SyncUserCollectionsRequest,
-  ): Promise<SyncUserCollectionsResult> {
-    const requestParams = { slice: this.client.sliceUri, ...params };
-    return await this.client.makeRequest<SyncUserCollectionsResult>(
-      "network.slices.slice.syncUserCollections",
+  async startSync(
+    input: NetworkSlicesSliceStartSyncInput,
+  ): Promise<NetworkSlicesSliceStartSyncOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceStartSyncOutput>(
+      "network.slices.slice.startSync",
       "POST",
-      requestParams,
+      input,
     );
   }
 
-  async createOAuthClient(
-    params: CreateOAuthClientRequest,
-  ): Promise<OAuthClientDetails | OAuthOperationError> {
-    const requestParams = { ...params, sliceUri: this.client.sliceUri };
-    return await this.client.makeRequest<
-      OAuthClientDetails | OAuthOperationError
-    >("network.slices.slice.createOAuthClient", "POST", requestParams);
+  async getJobHistory(
+    params?: NetworkSlicesSliceGetJobHistoryParams,
+  ): Promise<NetworkSlicesSliceGetJobHistoryOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetJobHistoryOutput>(
+      "network.slices.slice.getJobHistory",
+      "GET",
+      params,
+    );
   }
 
-  async getOAuthClients(): Promise<ListOAuthClientsResponse> {
-    const requestParams = { slice: this.client.sliceUri };
-    return await this.client.makeRequest<ListOAuthClientsResponse>(
-      "network.slices.slice.getOAuthClients",
+  async stats(
+    params?: NetworkSlicesSliceStatsParams,
+  ): Promise<NetworkSlicesSliceStatsOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceStatsOutput>(
+      "network.slices.slice.stats",
       "GET",
-      requestParams,
+      params,
     );
   }
 
   async updateOAuthClient(
-    params: UpdateOAuthClientRequest,
-  ): Promise<OAuthClientDetails | OAuthOperationError> {
-    const requestParams = { ...params, sliceUri: this.client.sliceUri };
+    input: NetworkSlicesSliceUpdateOAuthClientInput,
+  ): Promise<NetworkSlicesSliceUpdateOAuthClientOutput> {
     return await this.client.makeRequest<
-      OAuthClientDetails | OAuthOperationError
-    >("network.slices.slice.updateOAuthClient", "POST", requestParams);
+      NetworkSlicesSliceUpdateOAuthClientOutput
+    >("network.slices.slice.updateOAuthClient", "POST", input);
   }
 
-  async deleteOAuthClient(
-    clientId: string,
-  ): Promise<DeleteOAuthClientResponse> {
-    return await this.client.makeRequest<DeleteOAuthClientResponse>(
-      "network.slices.slice.deleteOAuthClient",
-      "POST",
-      { clientId },
-    );
+  async getOAuthClients(
+    params?: NetworkSlicesSliceGetOAuthClientsParams,
+  ): Promise<NetworkSlicesSliceGetOAuthClientsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetOAuthClientsOutput
+    >("network.slices.slice.getOAuthClients", "GET", params);
   }
 }
 

frontend/src/features/auth/handlers.tsx

···
     // Sync external collections first to ensure actor records are populated
     try {
       if (userInfo?.sub) {
-        await sessionClient.network.slices.slice.syncUserCollections();
+        await sessionClient.network.slices.slice.syncUserCollections({
+          slice: SLICE_URI!,
+        });
       }
     } catch (error) {
       console.error("Error during external collections sync:", error);
···
 
       // Sync user collections to populate their Bluesky profile data
       try {
-        await sessionClient.network.slices.slice.syncUserCollections();
+        await sessionClient.network.slices.slice.syncUserCollections({
+          slice: SLICE_URI!,
+        });
       } catch (syncError) {
         console.error(
           "Failed to sync user collections for waitlist user:",

frontend/src/features/docs/handlers.tsx

···
 async function handleDocsIndex(request: Request): Promise<Response> {
   const { currentUser } = await withAuth(request);
   return renderHTML(
-    <DocsIndexPage
-      docs={AVAILABLE_DOCS}
-      categories={DOCS_CATEGORIES}
-      currentUser={currentUser}
-    />
+    <DocsIndexPage categories={DOCS_CATEGORIES} currentUser={currentUser} />
   );
 }
 

frontend/src/features/docs/templates/DocsIndexPage.tsx

···
 }
 
 interface DocsIndexPageProps {
-  docs: DocItem[];
   categories: DocCategory[];
   currentUser?: AuthenticatedUser;
 }
 
-export function DocsIndexPage({ docs, categories, currentUser }: DocsIndexPageProps) {
+export function DocsIndexPage({ categories, currentUser }: DocsIndexPageProps) {
   return (
     <Layout title="Documentation - Slices" currentUser={currentUser}>
       <div className="py-8 px-4 max-w-6xl mx-auto">
···
           <Text as="h1" size="3xl" className="font-bold mb-4">
             Slices Documentation
           </Text>
-          <Text as="p" size="lg" variant="secondary" className="leading-relaxed">
-            Learn how to build AT Protocol applications with Slices. These guides cover everything from basic concepts to advanced usage patterns.
+          <Text
+            as="p"
+            size="lg"
+            variant="secondary"
+            className="leading-relaxed"
+          >
+            Learn how to build AT Protocol applications with Slices. These
+            guides cover everything from basic concepts to advanced usage
+            patterns.
           </Text>
         </div>
 
         <div className="space-y-16">
           {categories.map((category) => (
             <section key={category.category}>
-              <Text as="h2" size="2xl" className="font-bold mb-8 text-zinc-900 dark:text-white">
+              <Text
+                as="h2"
+                size="2xl"
+                className="font-bold mb-8 text-zinc-900 dark:text-white"
+              >
                 {category.category}
               </Text>
               <div className="space-y-6">
                 {category.docs.map((doc) => (
-                  <div key={doc.slug} className="border-b border-zinc-200 dark:border-zinc-700 pb-6">
+                  <div
+                    key={doc.slug}
+                    className="border-b border-zinc-200 dark:border-zinc-700 pb-6"
+                  >
                     <a
                       href={`/docs/${doc.slug}`}
                       className="block group hover:no-underline"
                     >
-                      <Text as="h3" size="lg" className="font-semibold mb-3 text-blue-600 dark:text-blue-400 group-hover:text-blue-700 dark:group-hover:text-blue-300 transition-colors underline decoration-blue-600 dark:decoration-blue-400">
+                      <Text
+                        as="h3"
+                        size="lg"
+                        className="font-semibold mb-3 text-blue-600 dark:text-blue-400 group-hover:text-blue-700 dark:group-hover:text-blue-300 transition-colors underline decoration-blue-600 dark:decoration-blue-400"
+                      >
                         {doc.title}
                       </Text>
-                      <Text as="p" variant="secondary" className="leading-relaxed text-base">
+                      <Text
+                        as="p"
+                        variant="secondary"
+                        className="leading-relaxed text-base"
+                      >
                         {doc.description}
                       </Text>
                     </a>
···
             </section>
           ))}
         </div>
-
       </div>
     </Layout>
   );
-}
+}

frontend/src/features/docs/templates/DocsPage.tsx

···
   title,
   content,
   headers,
-  docs,
-  categories,
-  currentSlug,
   currentUser,
 }: DocsPageProps) {
   return (
-    <Layout
-      title={`${title} - Slices`}
-      currentUser={currentUser}
-    >
+    <Layout title={`${title} - Slices`} currentUser={currentUser}>
       <div className="py-8 px-4 max-w-6xl mx-auto relative">
         {/* Breadcrumb */}
         <Breadcrumb
-          items={[
-            { label: "Documentation", href: "/docs" },
-            { label: title }
-          ]}
+          items={[{ label: "Documentation", href: "/docs" }, { label: title }]}
         />
 
         {/* Two-column layout */}
···
           {headers.length > 0 && (
             <aside className="hidden lg:flex w-64 flex-shrink-0 relative">
               <div className="sticky top-1/2 -translate-y-1/2 w-64 max-h-[60vh] overflow-y-auto bg-zinc-50 dark:bg-zinc-900/50 border border-zinc-200 dark:border-zinc-700 rounded-lg p-4 shadow-sm">
-                <Text as="h3" size="sm" className="font-semibold mb-4 text-zinc-900 dark:text-white">
+                <Text
+                  as="h3"
+                  size="sm"
+                  className="font-semibold mb-4 text-zinc-900 dark:text-white"
+                >
                   On This Page
                 </Text>
                 <nav>

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

···
 import { extractSliceParams } from "../../../utils/slice-params.ts";
 import { SliceCodegenPage } from "./templates/SliceCodegenPage.tsx";
 import { generateTypeScript } from "@slices/codegen";
-import { SLICE_URI } from "../../../config.ts";
 
 async function handleSliceCodegenPage(
   req: Request,
···
     });
 
     // Generate TypeScript client using convenience function
-    // If this is the main slice (SLICE_URI), include slices client functionality
-    const excludeSlicesClient = context.sliceContext!.sliceUri !== SLICE_URI;
     generatedCode = await generateTypeScript(lexicons, {
       sliceUri: context.sliceContext!.sliceUri,
-      excludeSlicesClient,
     });
   } catch (e) {
     console.error("Codegen error:", e);

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

···
 import { JetstreamLogs } from "./templates/fragments/JetstreamLogs.tsx";
 import { JetstreamStatus } from "./templates/fragments/JetstreamStatus.tsx";
 import { JetstreamStatusDisplay } from "./templates/fragments/JetstreamStatusDisplay.tsx";
-import { buildSliceUrl } from "../../../utils/slice-params.ts";
-import type { LogEntry } from "../../../client.ts";
+import { NetworkSlicesSliceGetJobLogsLogEntry } from "../../../client.ts";
+import { buildSliceUri } from "../../../utils/at-uri.ts";
 
 async function handleJetstreamLogs(
   req: Request,
···
     // Use the slice-specific client
     const sliceClient = getSliceClient(context, sliceId);
 
+    // Build slice URI from the user's DID and sliceId
+    const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
+
     // Get Jetstream logs
     const result = await sliceClient.network.slices.slice.getJetstreamLogs({
+      slice: sliceUri,
       limit: 100,
     });
 
···
   try {
     // Extract parameters from query
     const url = new URL(req.url);
-    const sliceId = url.searchParams.get("sliceId");
-    const handle = url.searchParams.get("handle");
     const isCompact = url.searchParams.get("compact") === "true";
+    const sliceId = url.searchParams.get("sliceId") || undefined;
+    const handle = url.searchParams.get("handle") || undefined;
 
     // Fetch jetstream status using the public client
     const data = await publicClient.network.slices.slice.getJetstreamStatus();
···
       );
     }
 
-    // Generate jetstream URL if we have both handle and sliceId
-    const jetstreamUrl =
-      handle && sliceId
-        ? buildSliceUrl(handle, sliceId, "jetstream")
-        : undefined;
-
     // Render full version for main page
     return renderHTML(
       <JetstreamStatus
         connected={data.connected}
-        status={data.status}
-        error={data.error}
-        jetstreamUrl={jetstreamUrl}
+        sliceId={sliceId}
+        handle={handle}
       />
     );
-  } catch (error) {
+  } catch (_error) {
     // Extract parameters for error case too
     const url = new URL(req.url);
-    const sliceId = url.searchParams.get("sliceId");
-    const handle = url.searchParams.get("handle");
     const isCompact = url.searchParams.get("compact") === "true";
+    const sliceId = url.searchParams.get("sliceId") || undefined;
+    const handle = url.searchParams.get("handle") || undefined;
 
     // Render compact error version
     if (isCompact) {
-      return renderHTML(
-        <JetstreamStatusDisplay connected={false} isCompact />
-      );
+      return renderHTML(<JetstreamStatusDisplay connected={false} isCompact />);
     }
 
-    // Generate jetstream URL if we have both handle and sliceId
-    const jetstreamUrl =
-      handle && sliceId
-        ? buildSliceUrl(handle, sliceId, "jetstream")
-        : undefined;
-
     // Fallback to disconnected state on error for full version
     return renderHTML(
-      <JetstreamStatus
-        connected={false}
-        status="Connection error"
-        error={error instanceof Error ? error.message : "Unknown error"}
-        jetstreamUrl={jetstreamUrl}
-      />
+      <JetstreamStatus connected={false} sliceId={sliceId} handle={handle} />
     );
   }
 }
···
   if (accessError) return accessError;
 
   // Fetch Jetstream logs
-  let logs: LogEntry[] = [];
+  let logs: NetworkSlicesSliceGetJobLogsLogEntry[] = [];
 
   try {
     const sliceClient = getSliceClient(authContext, sliceParams.sliceId);
 
     const logsResult = await sliceClient.network.slices.slice.getJetstreamLogs({
+      slice: context.sliceContext!.sliceUri,
       limit: 100,
     });
     logs = logsResult.logs.sort(

frontend/src/features/slices/jetstream/templates/JetstreamLogsPage.tsx

···
 import type {
-  LogEntry,
   NetworkSlicesSliceDefsSliceView,
+  NetworkSlicesSliceGetJobLogsLogEntry,
 } from "../../../../client.ts";
 import { SliceLogPage } from "../../shared/fragments/SliceLogPage.tsx";
 import { JetstreamLogs } from "./fragments/JetstreamLogs.tsx";
···
 
 interface JetstreamLogsPageProps {
   slice: NetworkSlicesSliceDefsSliceView;
-  logs: LogEntry[];
+  logs: NetworkSlicesSliceGetJobLogsLogEntry[];
   sliceId: string;
   currentUser?: AuthenticatedUser;
 }

frontend/src/features/slices/jetstream/templates/fragments/JetstreamLogs.tsx

···
-import type { LogEntry } from "../../../../../client.ts";
 import { formatTimestamp } from "../../../../../utils/time.ts";
 import { LogViewer } from "../../../../../shared/fragments/LogViewer.tsx";
+import { NetworkSlicesSliceGetJobLogsLogEntry } from "../../../../../client.ts";
 
 interface JetstreamLogsProps {
-  logs: LogEntry[];
+  logs: NetworkSlicesSliceGetJobLogsLogEntry[];
 }
 
 export function JetstreamLogs({ logs }: JetstreamLogsProps) {

frontend/src/features/slices/jetstream/templates/fragments/JetstreamStatus.tsx

···
-import { Button } from "../../../../../shared/fragments/Button.tsx";
 import { Card } from "../../../../../shared/fragments/Card.tsx";
 import { Text } from "../../../../../shared/fragments/Text.tsx";
+import { Button } from "../../../../../shared/fragments/Button.tsx";
 
 interface JetstreamStatusProps {
   connected: boolean;
-  status: string;
-  error?: string;
-  jetstreamUrl?: string;
+  sliceId?: string;
+  handle?: string;
 }
 
-export function JetstreamStatus({
-  connected,
-  status,
-  error,
-  jetstreamUrl,
-}: JetstreamStatusProps) {
+export function JetstreamStatus({ connected, sliceId, handle }: JetstreamStatusProps) {
+  const showViewLogs = sliceId && handle;
+
   if (connected) {
     return (
-      <Card padding="sm" className="bg-green-50 dark:bg-green-900/20 border-green-200 dark:border-green-800 mb-6">
+      <Card
+        padding="sm"
+        className="bg-green-50 dark:bg-green-900/20 border-green-200 dark:border-green-800 mb-6"
+      >
         <div className="flex items-center justify-between">
           <div className="flex items-center">
-            <div className="w-3 h-3 bg-green-500 rounded-full mr-3 animate-pulse">
-            </div>
+            <div className="w-3 h-3 bg-green-500 rounded-full mr-3 animate-pulse"></div>
             <div>
-              <Text as="h3" size="sm" variant="success" className="font-semibold block">
+              <Text
+                as="h3"
+                size="sm"
+                variant="success"
+                className="font-semibold block"
+              >
                 ✈️ Jetstream Connected
               </Text>
               <Text as="p" size="xs" variant="success">
-                Real-time indexing active - new records are automatically
-                indexed
+                Real-time indexing active - new records are automatically indexed
               </Text>
             </div>
           </div>
-          <div className="flex items-center gap-3">
-            {jetstreamUrl && (
+          {showViewLogs && (
+            <div className="flex items-center gap-3">
               <Button
-                href={jetstreamUrl}
+                href={`/profile/${handle}/slice/${sliceId}/jetstream`}
                 variant="success"
                 size="sm"
                 className="whitespace-nowrap"
               >
                 View Logs
               </Button>
-            )}
-          </div>
+            </div>
+          )}
         </div>
       </Card>
     );
   } else {
     return (
-      <Card padding="sm" className="bg-red-50 dark:bg-red-900/20 border-red-200 dark:border-red-800 mb-6">
+      <Card
+        padding="sm"
+        className="bg-red-50 dark:bg-red-900/20 border-red-200 dark:border-red-800 mb-6"
+      >
         <div className="flex items-center justify-between">
           <div className="flex items-center">
             <div className="w-3 h-3 bg-red-500 rounded-full mr-3"></div>
             <div>
-              <Text as="h3" size="sm" variant="error" className="font-semibold block">
+              <Text
+                as="h3"
+                size="sm"
+                variant="error"
+                className="font-semibold block"
+              >
                 🌊 Jetstream Disconnected
               </Text>
               <Text as="p" size="xs" variant="error">
-                Real-time indexing not active - {status}
+                Real-time indexing not active
               </Text>
-              {error && (
-                <Text as="p" size="xs" variant="error" className="mt-1">Error: {error}</Text>
-              )}
             </div>
           </div>
-          <div className="flex items-center gap-3">
-            {jetstreamUrl && (
+          {showViewLogs && (
+            <div className="flex items-center gap-3">
               <Button
-                href={jetstreamUrl}
+                href={`/profile/${handle}/slice/${sliceId}/jetstream`}
                 variant="danger"
                 size="sm"
                 className="whitespace-nowrap"
               >
                 View Logs
               </Button>
-            )}
-          </div>
+            </div>
+          )}
         </div>
       </Card>
     );

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

···
   requireSliceAccess,
   withSliceAccess,
 } from "../../../routes/slice-middleware.ts";
-import {
-  extractSliceParams,
-} from "../../../utils/slice-params.ts";
+import { extractSliceParams } from "../../../utils/slice-params.ts";
 import { renderHTML } from "../../../utils/render.tsx";
 import { SliceOAuthPage } from "./templates/SliceOAuthPage.tsx";
 import { OAuthClientModal } from "./templates/fragments/OAuthClientModal.tsx";
···
         sliceUri={sliceUri}
         mode="new"
         clientData={undefined}
-      />,
+      />
     );
   } catch (error) {
     console.error("Error showing new OAuth client modal:", error);
···
           Close
         </button>
       </div>,
-      { status: 500 },
+      { status: 500 }
     );
   }
 }
···
       .map((uri) => uri.trim())
       .filter((uri) => uri.length > 0);
 
-    // Register new OAuth client via backend API
     const sliceClient = getSliceClient(context, sliceId);
-    const result = await sliceClient.network.slices.slice.createOAuthClient({
+    await sliceClient.network.slices.slice.createOAuthClient({
+      sliceUri: buildAtUri({
+        did: context.currentUser.sub!,
+        collection: "network.slices.slice",
+        rkey: sliceId,
+      }),
       clientName,
       redirectUris,
       scope: scope || undefined,
···
       policyUri: policyUri || undefined,
     });
 
-    // Check if the result indicates success/failure
-    if (typeof result === 'object' && 'success' in result && result.success === false) {
-      return renderHTML(
-        <OAuthResult
-          success={false}
-          message={result.message || "OAuth client registration failed"}
-        />
-      );
-    }
-
     return renderHTML(
-      <OAuthResult
-        success
-        message="OAuth client registered successfully"
-      />
+      <OAuthResult success message="OAuth client registered successfully" />
     );
   } catch (error) {
     console.error("Error registering OAuth client:", error);
···
         // If we can't parse JSON, try to extract from the error message
         const errorStr = error.message;
         if (errorStr.includes("Invalid redirect URI")) {
-          errorMessage = "Invalid redirect URI format. Please ensure all redirect URIs use proper HTTP/HTTPS format.";
+          errorMessage =
+            "Invalid redirect URI format. Please ensure all redirect URIs use proper HTTP/HTTPS format.";
         } else if (errorStr.includes("Bad Request")) {
           errorMessage = errorStr;
         }
       }
     }
 
-    return renderHTML(
-      <OAuthResult
-        success={false}
-        message={errorMessage}
-      />
-    );
+    return renderHTML(<OAuthResult success={false} message={errorMessage} />);
   }
 }
 
···
   try {
     // Delete OAuth client via backend API
     const sliceClient = getSliceClient(context, sliceId);
-    await sliceClient.network.slices.slice.deleteOAuthClient(clientId);
+    await sliceClient.network.slices.slice.deleteOAuthClient({
+      clientId,
+    });
 
     return renderHTML(<OAuthDeleteResult success />);
   } catch (error) {
···
         success={false}
         error={error instanceof Error ? error.message : String(error)}
       />,
-      { status: 500 },
+      { status: 500 }
     );
   }
 }
···
   const clientId = decodeURIComponent(pathParts[5]);
 
   try {
-    // Fetch OAuth client details via backend API
-    const sliceClient = getSliceClient(context, sliceId);
-    const clientsResponse = await sliceClient.network.slices.slice
-      .getOAuthClients();
-    const clientData = clientsResponse.clients.find(
-      (c) => c.clientId === clientId,
-    );
-
+    // Construct sliceUri first
     const sliceUri = buildAtUri({
       did: context.currentUser.sub!,
       collection: "network.slices.slice",
       rkey: sliceId,
     });
 
+    // Fetch OAuth client details via backend API
+    const sliceClient = getSliceClient(context, sliceId);
+    const clientsResponse =
+      await sliceClient.network.slices.slice.getOAuthClients({
+        slice: sliceUri,
+      });
+    const clientData = clientsResponse.clients.find(
+      (c) => c.clientId === clientId
+    );
+
     return renderHTML(
       <OAuthClientModal
         sliceId={sliceId}
         sliceUri={sliceUri}
         mode="view"
         clientData={clientData}
-      />,
+      />
     );
   } catch (error) {
     console.error("Error fetching OAuth client:", error);
···
           Close
         </button>
       </div>,
-      { status: 500 },
+      { status: 500 }
     );
   }
 }
···
       .map((uri) => uri.trim())
       .filter((uri) => uri.length > 0);
 
-    // Update OAuth client via backend API
     const sliceClient = getSliceClient(context, sliceId);
-    const result = await sliceClient.network.slices.slice
-      .updateOAuthClient({
-        clientId,
-        clientName: clientName || undefined,
-        redirectUris: redirectUris.length > 0 ? redirectUris : undefined,
-        scope: scope || undefined,
-        clientUri: clientUri || undefined,
-        logoUri: logoUri || undefined,
-        tosUri: tosUri || undefined,
-        policyUri: policyUri || undefined,
-      });
-
-    // Check if the result indicates success/failure
-    if (typeof result === 'object' && 'success' in result && result.success === false) {
-      return renderHTML(
-        <OAuthResult
-          success={false}
-          message={result.message || "OAuth client update failed"}
-        />
-      );
-    }
+    await sliceClient.network.slices.slice.updateOAuthClient({
+      clientId,
+      clientName: clientName || undefined,
+      redirectUris: redirectUris.length > 0 ? redirectUris : undefined,
+      scope: scope || undefined,
+      clientUri: clientUri || undefined,
+      logoUri: logoUri || undefined,
+      tosUri: tosUri || undefined,
+      policyUri: policyUri || undefined,
+    });
 
     return renderHTML(
-      <OAuthResult
-        success
-        message="OAuth client updated successfully"
-      />
+      <OAuthResult success message="OAuth client updated successfully" />
     );
   } catch (error) {
     console.error("Error updating OAuth client:", error);
···
         // If we can't parse JSON, try to extract from the error message
         const errorStr = error.message;
         if (errorStr.includes("Invalid redirect URI")) {
-          errorMessage = "Invalid redirect URI format. Please ensure all redirect URIs use proper HTTP/HTTPS format.";
+          errorMessage =
+            "Invalid redirect URI format. Please ensure all redirect URIs use proper HTTP/HTTPS format.";
         } else if (errorStr.includes("Bad Request")) {
           errorMessage = errorStr;
         }
       }
     }
 
-    return renderHTML(
-      <OAuthResult
-        success={false}
-        message={errorMessage}
-      />
-    );
+    return renderHTML(<OAuthResult success={false} message={errorMessage} />);
   }
 }
 
 async function handleSliceOAuthPage(
   req: Request,
-  params?: URLPatternResult,
+  params?: URLPatternResult
 ): Promise<Response> {
   const authContext = await withAuth(req);
   const sliceParams = extractSliceParams(params);
···
   const context = await withSliceAccess(
     authContext,
     sliceParams.handle,
-    sliceParams.sliceId,
+    sliceParams.sliceId
   );
   const accessError = requireSliceAccess(context);
   if (accessError) return accessError;
···
   let errorMessage = null;
 
   try {
-    const oauthClientsResponse = await sliceClient.network.slices.slice
-      .getOAuthClients();
+    const oauthClientsResponse =
+      await sliceClient.network.slices.slice.getOAuthClients({
+        slice: context.sliceContext!.sliceUri,
+      });
     clientsWithDetails = oauthClientsResponse.clients.map((client) => ({
       clientId: client.clientId,
       createdAt: new Date().toISOString(), // Backend should provide this
···
       currentUser={authContext.currentUser}
       error={errorMessage}
       hasSliceAccess={context.sliceContext?.hasAccess}
-    />,
+    />
   );
 }
 

frontend/src/features/slices/oauth/templates/fragments/OAuthClientModal.tsx

···
-import { OAuthClientDetails } from "../../../../../client.ts";
 import { Button } from "../../../../../shared/fragments/Button.tsx";
 import { Input } from "../../../../../shared/fragments/Input.tsx";
 import { Textarea } from "../../../../../shared/fragments/Textarea.tsx";
 import { Modal } from "../../../../../shared/fragments/Modal.tsx";
 import { Text } from "../../../../../shared/fragments/Text.tsx";
+import { NetworkSlicesSliceGetOAuthClientsOauthClientDetails } from "../../../../../client.ts";
 
 interface OAuthClientModalProps {
   sliceId: string;
   sliceUri: string;
   mode: "new" | "view";
-  clientData?: OAuthClientDetails;
+  clientData?: NetworkSlicesSliceGetOAuthClientsOauthClientDetails;
 }
 
 export function OAuthClientModal({

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

···
   withSliceAccess,
 } from "../../../routes/slice-middleware.ts";
 import { extractSliceParams } from "../../../utils/slice-params.ts";
-import type { IndexedRecord } from "@slices/client";
+import type { NetworkSlicesSliceGetSliceRecordsIndexedRecord } from "../../../client.ts";
 import { RecordsList } from "./templates/fragments/RecordsList.tsx";
 import { Card } from "../../../shared/fragments/Card.tsx";
 import { EmptyState } from "../../../shared/fragments/EmptyState.tsx";
···
   const searchQuery = url.searchParams.get("search") || "";
 
   // Fetch real records if a collection is selected
-  let records: Array<IndexedRecord & { pretty_value: string }> = [];
+  let records: Array<
+    NetworkSlicesSliceGetSliceRecordsIndexedRecord & { pretty_value: string }
+  > = [];
 
   if (
     (selectedCollection || (searchQuery && searchQuery.trim() !== "")) &&
···
       );
       const recordsResult =
         await sliceClient.network.slices.slice.getSliceRecords({
+          slice: context.sliceContext.sliceUri,
           where: {
             ...(selectedCollection && {
               collection: { eq: selectedCollection },
···
           limit: 20,
         });
 
-      if (recordsResult.success) {
-        records = recordsResult.records.map((record) => ({
-          uri: record.uri,
-          indexedAt: record.indexedAt,
-          collection: record.collection,
-          did: record.did,
-          cid: record.cid,
-          value: record.value,
-          pretty_value: JSON.stringify(record.value, null, 2),
-        }));
-      }
+      records = recordsResult.records.map((record) => ({
+        uri: record.uri,
+        indexedAt: record.indexedAt,
+        collection: record.collection,
+        did: record.did,
+        cid: record.cid,
+        value: record.value,
+        pretty_value: JSON.stringify(record.value, null, 2),
+      }));
     } catch (error) {
       console.error("Failed to fetch records:", error);
     }

frontend/src/features/slices/records/templates/SliceRecordsPage.tsx

···
 import { Database } from "lucide-preact";
 import { buildSliceUrlFromView } from "../../../../utils/slice-params.ts";
 import type { AuthenticatedUser } from "../../../../routes/middleware.ts";
-import type { NetworkSlicesSliceDefsSliceView } from "../../../../client.ts";
-import { IndexedRecord } from "@slices/client";
+import type { NetworkSlicesSliceDefsSliceView, NetworkSlicesSliceGetSliceRecordsIndexedRecord } from "../../../../client.ts";
 
-interface Record extends IndexedRecord {
+interface Record extends NetworkSlicesSliceGetSliceRecordsIndexedRecord {
   pretty_value?: string;
 }
 

frontend/src/features/slices/records/templates/fragments/RecordsList.tsx

···
-import { IndexedRecord } from "@slices/client";
 import { Card } from "../../../../../shared/fragments/Card.tsx";
 import { Text } from "../../../../../shared/fragments/Text.tsx";
+import type { NetworkSlicesSliceGetSliceRecordsIndexedRecord } from "../../../../../client.ts";
 
-interface Record extends IndexedRecord {
+interface Record extends NetworkSlicesSliceGetSliceRecordsIndexedRecord {
   pretty_value?: string;
 }
 

frontend/src/features/slices/sync-logs/templates/SyncJobLogs.tsx

···
-import type { LogEntry } from "../../../../client.ts";
+import { NetworkSlicesSliceGetJobLogsLogEntry } from "../../../../client.ts";
 import { LogViewer } from "../../../../shared/fragments/LogViewer.tsx";
 
 interface SyncJobLogsProps {
-  logs: LogEntry[];
+  logs: NetworkSlicesSliceGetJobLogsLogEntry[];
 }
 
 export function SyncJobLogs({ logs }: SyncJobLogsProps) {

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

···
     }
 
     const sliceClient = getSliceClient(context, sliceId);
-    const syncJobResponse = await sliceClient.network.slices.slice.startSync({
+    await sliceClient.network.slices.slice.startSync({
+      slice: buildSliceUri(context.currentUser.sub!, sliceId),
       collections: collections.length > 0 ? collections : undefined,
       externalCollections:
         externalCollections.length > 0 ? externalCollections : undefined,
       repos: repos.length > 0 ? repos : undefined,
     });
 
-    if (syncJobResponse.success) {
-      // Get the user's handle for the redirect
-      const handle = context.currentUser?.handle;
-      if (!handle) {
-        throw new Error("Unable to determine user handle");
-      }
+    const handle = context.currentUser?.handle;
+    if (!handle) {
+      throw new Error("Unable to determine user handle");
+    }
 
-      // Redirect to the sync page to show the job started
-      const redirectUrl = buildSliceUrl(handle, sliceId, "sync");
-      return hxRedirect(redirectUrl);
-    } else {
-      return renderHTML(
-        <SyncResult
-          success={false}
-          message={syncJobResponse.message}
-          error={syncJobResponse.message}
-        />
-      );
-    }
+    const redirectUrl = buildSliceUrl(handle, sliceId, "sync");
+    return hxRedirect(redirectUrl);
   } catch (error) {
     console.error("Failed to start sync:", error);
     const errorMessage = error instanceof Error ? error.message : String(error);

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

···
 import { Text } from "../../../../../shared/fragments/Text.tsx";
 import { timeAgo } from "../../../../../utils/time.ts";
 import { buildSliceUrl } from "../../../../../utils/slice-params.ts";
-
-interface JobResult {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-interface JobHistoryItem {
-  jobId: string;
-  status: string;
-  createdAt: string;
-  completedAt?: string;
-  result?: JobResult;
-  error?: string;
-}
+import { NetworkSlicesSliceGetJobHistoryOutput } from "../../../../../client.ts";
 
 interface JobHistoryProps {
-  jobs: JobHistoryItem[];
+  jobs: NetworkSlicesSliceGetJobHistoryOutput;
   sliceId: string;
   handle?: string;
 }

frontend/src/features/slices/waitlist/api.ts

···
   try {
     // Fetch actors to get handles
     const actorsResponse = await client.network.slices.slice.getActors({
+      slice: sliceUri,
       where: {
-        did: { in: dids }
-      }
+        did: { in: dids },
+      },
     });
 
     // Create a map of DIDs to handles
···
   try {
     // Fetch actors to get handles
     const actorsResponse = await client.network.slices.slice.getActors({
+      slice: sliceUri,
       where: {
-        did: { in: dids }
-      }
+        did: { in: dids },
+      },
     });
 
     // Create a map of DIDs to handles

frontend/src/lib/api.ts

···
   NetworkSlicesSlice,
   NetworkSlicesSliceDefsSliceView,
   NetworkSlicesSliceDefsSparklinePoint,
-  SliceStatsOutput,
+  NetworkSlicesSliceStatsOutput,
 } from "../client.ts";
 import { recordBlobToCdnUrl, RecordResponse } from "@slices/client";
 
···
       slices: sliceUris,
       duration: "24h",
     });
-    if (sparklinesResponse.success) {
-      return sparklinesResponse.sparklines;
+
+    // Convert array of sparklineEntry objects to a map
+    const sparklinesMap: Record<string, NetworkSlicesSliceDefsSparklinePoint[]> = {};
+    for (const entry of sparklinesResponse.sparklines) {
+      sparklinesMap[entry.sliceUri] = entry.points;
     }
+    return sparklinesMap;
   } catch (error) {
     console.warn("Failed to fetch batch sparkline data:", error);
   }
···
 async function fetchStatsForSlice(
   client: AtProtoClient,
   sliceUri: string
-): Promise<SliceStatsOutput | null> {
+): Promise<NetworkSlicesSliceStatsOutput | null> {
   try {
     const statsResponse = await client.network.slices.slice.stats({
       slice: sliceUri,
     });
-    if (statsResponse.success) {
-      return statsResponse;
-    }
+    return statsResponse;
   } catch (error) {
     console.warn("Failed to fetch stats for slice:", sliceUri, error);
   }
···
 async function fetchStatsForSlices(
   client: AtProtoClient,
   sliceUris: string[]
-): Promise<Record<string, SliceStatsOutput | null>> {
-  const statsMap: Record<string, SliceStatsOutput | null> = {};
+): Promise<Record<string, NetworkSlicesSliceStatsOutput | null>> {
+  const statsMap: Record<string, NetworkSlicesSliceStatsOutput | null> = {};
 
   // Fetch stats for each slice individually (no batch stats endpoint yet)
   await Promise.all(
···
   sliceRecord: RecordResponse<NetworkSlicesSlice>,
   creator: NetworkSlicesActorDefsProfileViewBasic,
   sparkline?: NetworkSlicesSliceDefsSparklinePoint[],
-  stats?: SliceStatsOutput | null
+  stats?: NetworkSlicesSliceStatsOutput | null
 ): NetworkSlicesSliceDefsSliceView {
   return {
     uri: sliceRecord.uri,

frontend/src/routes/slice-middleware.ts

···
       slice: sliceUri,
     });
 
-    if (!stats.success) {
-      return defaultStats;
-    }
-
     return {
       totalRecords: stats.totalRecords,
       totalActors: stats.totalActors,

frontend/src/shared/fragments/LogViewer.tsx

···
-import type { LogEntry } from "../../client.ts";
 import { LogLevelBadge } from "./LogLevelBadge.tsx";
 import { Text } from "./Text.tsx";
 import { Card } from "./Card.tsx";
+import { NetworkSlicesSliceGetJobLogsLogEntry } from "../../client.ts";
 
 interface LogViewerProps {
-  logs: LogEntry[];
+  logs: NetworkSlicesSliceGetJobLogsLogEntry[];
   emptyMessage?: string;
   formatTimestamp?: (timestamp: string) => string;
 }
···
   if (logs.length === 0) {
     return (
       <div className="p-8 text-center">
-        <Text as="p" variant="muted">{emptyMessage}</Text>
+        <Text as="p" variant="muted">
+          {emptyMessage}
+        </Text>
       </div>
     );
   }
···
               Warnings: <strong>{warnCount}</strong>
             </Text>
           )}
-          <Text as="span" size="sm" className="text-blue-600 dark:text-blue-400">
+          <Text
+            as="span"
+            size="sm"
+            className="text-blue-600 dark:text-blue-400"
+          >
             Info: <strong>{infoCount}</strong>
           </Text>
         </div>
···
               </Text>
               <LogLevelBadge level={log.level} />
               <div className="flex-1">
-                <Text as="div" size="sm">{log.message}</Text>
+                <Text as="div" size="sm">
+                  {log.message}
+                </Text>
                 {log.metadata && Object.keys(log.metadata).length > 0 && (
                   <details className="mt-2">
                     <summary
···
                       /* @ts-ignore - Hyperscript attribute */
                       _="on click toggle .hidden on next <pre/>"
                     >
-                      <Text as="span" size="xs" variant="muted">View metadata</Text>
+                      <Text as="span" size="xs" variant="muted">
+                        View metadata
+                      </Text>
                     </summary>
                     <pre className="mt-2 p-2 bg-zinc-100 dark:bg-zinc-800 rounded text-xs overflow-x-auto break-words whitespace-pre-wrap hidden">
-                      <Text as="span" size="xs">{JSON.stringify(log.metadata, null, 2)}</Text>
+                      <Text as="span" size="xs">
+                        {JSON.stringify(log.metadata, null, 2)}
+                      </Text>
                     </pre>
                   </details>
                 )}

lexicons/network/slices/slice/createOAuthClient.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.createOAuthClient",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Register a new OAuth client for a slice. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["sliceUri", "clientName", "redirectUris"],
+          "properties": {
+            "sliceUri": {
+              "type": "string",
+              "description": "AT-URI of the slice to register the OAuth client for"
+            },
+            "clientName": {
+              "type": "string",
+              "description": "Human-readable name of the OAuth client",
+              "maxLength": 256
+            },
+            "redirectUris": {
+              "type": "array",
+              "description": "Allowed redirect URIs for OAuth flow (must use HTTP or HTTPS)",
+              "minLength": 1,
+              "items": {
+                "type": "string",
+                "format": "uri"
+              }
+            },
+            "grantTypes": {
+              "type": "array",
+              "description": "OAuth grant types",
+              "items": {
+                "type": "string"
+              }
+            },
+            "responseTypes": {
+              "type": "array",
+              "description": "OAuth response types",
+              "items": {
+                "type": "string"
+              }
+            },
+            "scope": {
+              "type": "string",
+              "description": "OAuth scope"
+            },
+            "clientUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "URI of the client application"
+            },
+            "logoUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "URI of the client logo"
+            },
+            "tosUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "URI of the terms of service"
+            },
+            "policyUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "URI of the privacy policy"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "network.slices.slice.getOAuthClients#oauthClientDetails"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/deleteOAuthClient.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.deleteOAuthClient",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete an OAuth client. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["clientId"],
+          "properties": {
+            "clientId": {
+              "type": "string",
+              "description": "OAuth client ID to delete"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["message"],
+          "properties": {
+            "message": {
+              "type": "string",
+              "description": "Success confirmation message"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getActors.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getActors",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Get actors (users) indexed in a slice with optional filtering and pagination.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["slice"],
+          "properties": {
+          "slice": {
+            "type": "string",
+            "description": "AT-URI of the slice to query"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "Maximum number of actors to return",
+            "default": 50,
+            "minimum": 1,
+            "maximum": 100
+          },
+          "cursor": {
+            "type": "string",
+            "description": "Pagination cursor from previous response"
+          },
+          "where": {
+            "type": "unknown",
+            "description": "Flexible filtering conditions for querying actors"
+          }
+        }
+      }
+    },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["actors"],
+          "properties": {
+            "actors": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#actor"
+              }
+            },
+            "cursor": {
+              "type": "string",
+              "description": "Pagination cursor for next page"
+            }
+          }
+        }
+      }
+    },
+    "actor": {
+      "type": "object",
+      "required": ["did", "sliceUri", "indexedAt"],
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did",
+          "description": "Decentralized identifier of the actor"
+        },
+        "handle": {
+          "type": "string",
+          "format": "handle",
+          "description": "Human-readable handle of the actor"
+        },
+        "sliceUri": {
+          "type": "string",
+          "description": "AT-URI of the slice this actor is indexed in"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When this actor was indexed"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getJetstreamLogs.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getJetstreamLogs",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get logs from the Jetstream real-time indexing service, optionally filtered by slice.",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "slice": {
+            "type": "string",
+            "description": "Optional slice AT-URI to filter logs by"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "Maximum number of log entries to return",
+            "default": 100,
+            "minimum": 1,
+            "maximum": 1000
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["logs"],
+          "properties": {
+            "logs": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "network.slices.slice.getJobLogs#logEntry"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getJetstreamStatus.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getJetstreamStatus",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the current connection status of the Jetstream real-time indexing service.",
+      "parameters": {
+        "type": "params",
+        "properties": {}
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["connected"],
+          "properties": {
+            "connected": {
+              "type": "boolean",
+              "description": "Whether Jetstream is currently connected and receiving events"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getJobHistory.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getJobHistory",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the sync job history for a user and slice combination.",
+      "parameters": {
+        "type": "params",
+        "required": ["userDid", "sliceUri"],
+        "properties": {
+          "userDid": {
+            "type": "string",
+            "format": "did",
+            "description": "DID of the user"
+          },
+          "sliceUri": {
+            "type": "string",
+            "description": "AT-URI of the slice"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "Maximum number of jobs to return",
+            "default": 10,
+            "minimum": 1,
+            "maximum": 100
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "array",
+          "items": {
+            "type": "ref",
+            "ref": "network.slices.slice.getJobStatus#jobStatus"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getJobLogs.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getJobLogs",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get logs for a specific sync job.",
+      "parameters": {
+        "type": "params",
+        "required": ["jobId"],
+        "properties": {
+          "jobId": {
+            "type": "string",
+            "description": "UUID of the sync job"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "Maximum number of log entries to return",
+            "default": 100,
+            "minimum": 1,
+            "maximum": 1000
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["logs"],
+          "properties": {
+            "logs": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#logEntry"
+              }
+            }
+          }
+        }
+      }
+    },
+    "logEntry": {
+      "type": "object",
+      "required": ["id", "createdAt", "logType", "level", "message"],
+      "properties": {
+        "id": {
+          "type": "integer",
+          "description": "Log entry ID"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When the log entry was created"
+        },
+        "logType": {
+          "type": "string",
+          "description": "Type of log entry",
+          "enum": ["sync_job", "jetstream", "system"]
+        },
+        "jobId": {
+          "type": "string",
+          "description": "UUID of related job if applicable"
+        },
+        "userDid": {
+          "type": "string",
+          "format": "did",
+          "description": "DID of related user if applicable"
+        },
+        "sliceUri": {
+          "type": "string",
+          "description": "AT-URI of related slice if applicable"
+        },
+        "level": {
+          "type": "string",
+          "description": "Log level",
+          "enum": ["debug", "info", "warn", "error"]
+        },
+        "message": {
+          "type": "string",
+          "description": "Log message"
+        },
+        "metadata": {
+          "type": "unknown",
+          "description": "Additional metadata associated with the log entry"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getJobStatus.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getJobStatus",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the status of a sync job by its ID.",
+      "parameters": {
+        "type": "params",
+        "required": ["jobId"],
+        "properties": {
+          "jobId": {
+            "type": "string",
+            "description": "UUID of the sync job"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "#jobStatus"
+        }
+      }
+    },
+    "jobStatus": {
+      "type": "object",
+      "required": ["jobId", "status", "createdAt", "retryCount"],
+      "properties": {
+        "jobId": {
+          "type": "string",
+          "description": "UUID of the job"
+        },
+        "status": {
+          "type": "string",
+          "description": "Current status of the job",
+          "enum": ["pending", "running", "completed", "failed"]
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When the job was created"
+        },
+        "startedAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When the job started executing"
+        },
+        "completedAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When the job completed"
+        },
+        "result": {
+          "type": "ref",
+          "ref": "#syncJobResult",
+          "description": "Job result if completed successfully"
+        },
+        "error": {
+          "type": "string",
+          "description": "Error message if job failed"
+        },
+        "retryCount": {
+          "type": "integer",
+          "description": "Number of times the job has been retried"
+        }
+      }
+    },
+    "syncJobResult": {
+      "type": "object",
+      "required": ["success", "totalRecords", "collectionsSynced", "reposProcessed", "message"],
+      "properties": {
+        "success": {
+          "type": "boolean",
+          "description": "Whether the sync job completed successfully"
+        },
+        "totalRecords": {
+          "type": "integer",
+          "description": "Total number of records synced"
+        },
+        "collectionsSynced": {
+          "type": "array",
+          "description": "List of collection NSIDs that were synced",
+          "items": {
+            "type": "string",
+            "format": "nsid"
+          }
+        },
+        "reposProcessed": {
+          "type": "integer",
+          "description": "Number of repositories processed"
+        },
+        "message": {
+          "type": "string",
+          "description": "Human-readable message about the job completion"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getOAuthClients.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getOAuthClients",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get all OAuth clients registered for a slice. Requires authentication.",
+      "parameters": {
+        "type": "params",
+        "required": ["slice"],
+        "properties": {
+          "slice": {
+            "type": "string",
+            "description": "AT-URI of the slice to get OAuth clients for"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["clients"],
+          "properties": {
+            "clients": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#oauthClientDetails"
+              }
+            }
+          }
+        }
+      }
+    },
+    "oauthClientDetails": {
+      "type": "object",
+      "required": ["clientId", "clientName", "redirectUris", "grantTypes", "responseTypes", "createdAt", "createdByDid"],
+      "properties": {
+        "clientId": {
+          "type": "string",
+          "description": "OAuth client ID"
+        },
+        "clientSecret": {
+          "type": "string",
+          "description": "OAuth client secret (only returned on creation)"
+        },
+        "clientName": {
+          "type": "string",
+          "description": "Human-readable name of the OAuth client"
+        },
+        "redirectUris": {
+          "type": "array",
+          "description": "Allowed redirect URIs for OAuth flow",
+          "items": {
+            "type": "string",
+            "format": "uri"
+          }
+        },
+        "grantTypes": {
+          "type": "array",
+          "description": "Allowed OAuth grant types",
+          "items": {
+            "type": "string"
+          }
+        },
+        "responseTypes": {
+          "type": "array",
+          "description": "Allowed OAuth response types",
+          "items": {
+            "type": "string"
+          }
+        },
+        "scope": {
+          "type": "string",
+          "description": "OAuth scope"
+        },
+        "clientUri": {
+          "type": "string",
+          "format": "uri",
+          "description": "URI of the client application"
+        },
+        "logoUri": {
+          "type": "string",
+          "format": "uri",
+          "description": "URI of the client logo"
+        },
+        "tosUri": {
+          "type": "string",
+          "format": "uri",
+          "description": "URI of the terms of service"
+        },
+        "policyUri": {
+          "type": "string",
+          "format": "uri",
+          "description": "URI of the privacy policy"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When the OAuth client was created"
+        },
+        "createdByDid": {
+          "type": "string",
+          "format": "did",
+          "description": "DID of the user who created this client"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getSliceRecords.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getSliceRecords",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Query records across all collections in a slice with filtering, sorting, and pagination.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["slice"],
+          "properties": {
+          "slice": {
+            "type": "string",
+            "description": "AT-URI of the slice to query"
+          },
+          "limit": {
+            "type": "integer",
+            "description": "Maximum number of records to return",
+            "default": 50,
+            "minimum": 1,
+            "maximum": 100
+          },
+          "cursor": {
+            "type": "string",
+            "description": "Pagination cursor from previous response"
+          },
+          "where": {
+            "type": "unknown",
+            "description": "Flexible filtering conditions for querying records"
+          },
+          "sortBy": {
+            "type": "unknown",
+            "description": "Sorting configuration for result ordering"
+          }
+        }
+      }
+    },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["records"],
+          "properties": {
+            "records": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#indexedRecord"
+              }
+            },
+            "cursor": {
+              "type": "string",
+              "description": "Pagination cursor for next page"
+            }
+          }
+        }
+      }
+    },
+    "indexedRecord": {
+      "type": "object",
+      "required": ["uri", "cid", "did", "collection", "value", "indexedAt"],
+      "properties": {
+        "uri": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "AT-URI of the record"
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid",
+          "description": "Content identifier of the record"
+        },
+        "did": {
+          "type": "string",
+          "format": "did",
+          "description": "DID of the record creator"
+        },
+        "collection": {
+          "type": "string",
+          "format": "nsid",
+          "description": "NSID of the collection this record belongs to"
+        },
+        "value": {
+          "type": "unknown",
+          "description": "The record value/content"
+        },
+        "indexedAt": {
+          "type": "string",
+          "format": "datetime",
+          "description": "When this record was indexed"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/getSparklines.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.getSparklines",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Get time-series sparkline data for multiple slices showing record indexing activity over time.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["slices"],
+          "properties": {
+          "slices": {
+            "type": "array",
+            "description": "Array of slice AT-URIs to get sparkline data for",
+            "items": {
+              "type": "string"
+            }
+          },
+          "interval": {
+            "type": "string",
+            "description": "Time interval for data points",
+            "default": "hour",
+            "enum": ["minute", "hour", "day"]
+          },
+          "duration": {
+            "type": "string",
+            "description": "Time range to fetch data for",
+            "default": "24h",
+            "enum": ["1h", "24h", "7d", "30d"]
+          }
+        }
+      }
+    },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["sparklines"],
+          "properties": {
+            "sparklines": {
+              "type": "array",
+              "description": "Array of slice sparkline data entries",
+              "items": {
+                "type": "ref",
+                "ref": "#sparklineEntry"
+              }
+            }
+          }
+        }
+      }
+    },
+    "sparklineEntry": {
+      "type": "object",
+      "required": ["sliceUri", "points"],
+      "properties": {
+        "sliceUri": {
+          "type": "string",
+          "description": "AT-URI of the slice"
+        },
+        "points": {
+          "type": "array",
+          "description": "Array of sparkline data points",
+          "items": {
+            "type": "ref",
+            "ref": "network.slices.slice.defs#sparklinePoint"
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/startSync.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.startSync",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Start a background sync job to index AT Protocol records into a slice. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["slice"],
+          "properties": {
+            "slice": {
+              "type": "string",
+              "description": "AT-URI of the slice to sync data into"
+            },
+            "collections": {
+              "type": "array",
+              "description": "List of collection NSIDs to sync (primary collections matching slice domain)",
+              "items": {
+                "type": "string",
+                "format": "nsid"
+              }
+            },
+            "externalCollections": {
+              "type": "array",
+              "description": "List of external collection NSIDs to sync (collections outside slice domain)",
+              "items": {
+                "type": "string",
+                "format": "nsid"
+              }
+            },
+            "repos": {
+              "type": "array",
+              "description": "List of specific repository DIDs to sync from",
+              "items": {
+                "type": "string",
+                "format": "did"
+              }
+            },
+            "limitPerRepo": {
+              "type": "integer",
+              "description": "Maximum number of records to sync per repository"
+            },
+            "skipValidation": {
+              "type": "boolean",
+              "description": "Skip lexicon validation during sync",
+              "default": false
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["jobId", "message"],
+          "properties": {
+            "jobId": {
+              "type": "string",
+              "description": "UUID of the enqueued sync job"
+            },
+            "message": {
+              "type": "string",
+              "description": "Success message confirming job enqueue"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/stats.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.stats",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get statistics for a slice including collection counts, record counts, and actor counts.",
+      "parameters": {
+        "type": "params",
+        "required": ["slice"],
+        "properties": {
+          "slice": {
+            "type": "string",
+            "description": "AT-URI of the slice to get statistics for"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["collections", "collectionStats", "totalLexicons", "totalRecords", "totalActors"],
+          "properties": {
+            "collections": {
+              "type": "array",
+              "description": "List of collection NSIDs indexed in this slice",
+              "items": {
+                "type": "string",
+                "format": "nsid"
+              }
+            },
+            "collectionStats": {
+              "type": "array",
+              "description": "Per-collection statistics",
+              "items": {
+                "type": "ref",
+                "ref": "#collectionStats"
+              }
+            },
+            "totalLexicons": {
+              "type": "integer",
+              "description": "Total number of lexicons defined for this slice"
+            },
+            "totalRecords": {
+              "type": "integer",
+              "description": "Total number of records indexed in this slice"
+            },
+            "totalActors": {
+              "type": "integer",
+              "description": "Total number of unique actors indexed in this slice"
+            }
+          }
+        }
+      }
+    },
+    "collectionStats": {
+      "type": "object",
+      "required": ["collection", "recordCount", "uniqueActors"],
+      "properties": {
+        "collection": {
+          "type": "string",
+          "format": "nsid",
+          "description": "Collection NSID"
+        },
+        "recordCount": {
+          "type": "integer",
+          "description": "Number of records in this collection"
+        },
+        "uniqueActors": {
+          "type": "integer",
+          "description": "Number of unique actors with records in this collection"
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/syncUserCollections.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.syncUserCollections",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Synchronously sync the authenticated user's collections into a slice with a configurable timeout. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["slice"],
+          "properties": {
+            "slice": {
+              "type": "string",
+              "description": "AT-URI of the slice to sync user data into"
+            },
+            "timeoutSeconds": {
+              "type": "integer",
+              "description": "Timeout in seconds for the sync operation",
+              "default": 30,
+              "minimum": 1,
+              "maximum": 300
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["reposProcessed", "recordsSynced", "timedOut"],
+          "properties": {
+            "reposProcessed": {
+              "type": "integer",
+              "description": "Number of repositories processed during sync"
+            },
+            "recordsSynced": {
+              "type": "integer",
+              "description": "Number of records successfully synced"
+            },
+            "timedOut": {
+              "type": "boolean",
+              "description": "Whether the sync operation exceeded the timeout"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/network/slices/slice/updateOAuthClient.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.updateOAuthClient",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update an existing OAuth client. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["clientId"],
+          "properties": {
+            "clientId": {
+              "type": "string",
+              "description": "OAuth client ID to update"
+            },
+            "clientName": {
+              "type": "string",
+              "description": "New human-readable name of the OAuth client",
+              "maxLength": 256
+            },
+            "redirectUris": {
+              "type": "array",
+              "description": "New allowed redirect URIs for OAuth flow",
+              "items": {
+                "type": "string",
+                "format": "uri"
+              }
+            },
+            "scope": {
+              "type": "string",
+              "description": "New OAuth scope"
+            },
+            "clientUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "New URI of the client application"
+            },
+            "logoUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "New URI of the client logo"
+            },
+            "tosUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "New URI of the terms of service"
+            },
+            "policyUri": {
+              "type": "string",
+              "format": "uri",
+              "description": "New URI of the privacy policy"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "network.slices.slice.getOAuthClients#oauthClientDetails"
+        }
+      }
+    }
+  }
+}

packages/cli/src/commands/codegen.ts

···
     --lexicons <PATH>      Directory containing lexicon files (default: ./lexicons or from slices.json)
     --output <PATH>        Output file path (default: ./generated_client.ts or from slices.json)
     --slice <SLICE_URI>    Target slice URI (required, or from slices.json)
-    --include-slices       Include Slices XRPC methods
     -h, --help            Show this help message
 
 EXAMPLES:
     slices codegen --slice at://did:plc:example/slice
     slices codegen --lexicons ./my-lexicons --output ./src/client.ts --slice at://did:plc:example/slice
-    slices codegen --include-slices --slice at://did:plc:example/slice
     slices codegen  # Uses config from slices.json
 `);
 }
···
   const lexiconsPath = resolve(mergedConfig.lexiconPath!);
   const outputPath = resolve(mergedConfig.clientOutputPath!);
   const sliceUri = mergedConfig.slice!;
-  const excludeSlices = !args["include-slices"] as boolean;
 
   try {
     const lexiconFiles = await findLexiconFiles(lexiconsPath);
···
 
     const generatedCode = await generateTypeScript(validLexicons, {
       sliceUri,
-      excludeSlicesClient: excludeSlices,
     });
 
     const outputDir = dirname(outputPath);
···
     await Deno.writeTextFile(outputPath, generatedCode);
 
     logger.success(`Generated client: ${outputPath}`);
-
-    if (!excludeSlices) {
-      logger.info("Includes network.slices XRPC client methods");
-    }
+    logger.info("Includes XRPC client methods");
   } catch (error) {
     const err = error as Error;
     logger.error(`Code generation failed: ${err.message}`);

packages/cli/src/generated_client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-24 17:50:27 UTC
-// Lexicons: 25
+// Generated at: 2025-09-26 18:21:58 UTC
+// Lexicons: 40
 
 /**
  * @example Usage
···
   type AuthProvider,
   type BlobRef,
   type CountRecordsResponse,
-  type GetActorsParams,
-  type GetActorsResponse,
   type GetRecordParams,
   type GetRecordsResponse,
   type IndexedRecordFields,
   type RecordResponse,
-  type SliceLevelRecordsParams,
-  type SliceRecordsOutput,
   SlicesClient,
   type SortField,
   type WhereCondition,
 } from "@slices/client";
 import type { OAuthClient } from "@slices/oauth";
-
-export interface BulkSyncParams {
-  collections?: string[];
-  externalCollections?: string[];
-  repos?: string[];
-  limitPerRepo?: number;
-}
-
-export interface BulkSyncOutput {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-export interface SyncJobResponse {
-  success: boolean;
-  jobId?: string;
-  message: string;
-}
-
-export interface SyncJobResult {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-export interface JobStatus {
-  jobId: string;
-  status: string;
-  createdAt: string;
-  startedAt?: string;
-  completedAt?: string;
-  result?: SyncJobResult;
-  error?: string;
-  retryCount: number;
-}
-
-export interface GetJobStatusParams {
-  jobId: string;
-}
-
-export interface GetJobHistoryParams {
-  userDid: string;
-  sliceUri: string;
-  limit?: number;
-}
-
-export type GetJobHistoryResponse = JobStatus[];
-
-export interface GetJobLogsParams {
-  jobId: string;
-  limit?: number;
-}
-
-export interface GetJobLogsResponse {
-  logs: LogEntry[];
-}
-
-export interface GetJetstreamLogsParams {
-  limit?: number;
-}
-
-export interface GetJetstreamLogsResponse {
-  logs: LogEntry[];
-}
-
-export interface LogEntry {
-  id: number;
-  createdAt: string;
-  logType: string;
-  jobId?: string;
-  userDid?: string;
-  sliceUri?: string;
-  level: string;
-  message: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface SyncUserCollectionsRequest {
-  slice: string;
-  timeoutSeconds?: number;
-}
-
-export interface SyncUserCollectionsResult {
-  success: boolean;
-  reposProcessed: number;
-  recordsSynced: number;
-  timedOut: boolean;
-  message: string;
-}
-
-export interface JetstreamStatusResponse {
-  connected: boolean;
-  status: string;
-  error?: string;
-}
-
-export interface CollectionStats {
-  collection: string;
-  recordCount: number;
-  uniqueActors: number;
-}
-
-export interface SliceStatsParams {
-  slice: string;
-}
-
-export interface SliceStatsOutput {
-  success: boolean;
-  collections: string[];
-  collectionStats: CollectionStats[];
-  totalLexicons: number;
-  totalRecords: number;
-  totalActors: number;
-  message?: string;
-}
-
-export interface GetSparklinesParams {
-  slices: string[];
-  interval?: string;
-  duration?: string;
-}
-
-export interface GetSparklinesOutput {
-  success: boolean;
-  sparklines: Record<string, NetworkSlicesSliceDefs["SparklinePoint"][]>;
-  message?: string;
-}
-
-export interface CreateOAuthClientRequest {
-  clientName: string;
-  redirectUris: string[];
-  grantTypes?: string[];
-  responseTypes?: string[];
-  scope?: string;
-  clientUri?: string;
-  logoUri?: string;
-  tosUri?: string;
-  policyUri?: string;
-}
-
-export interface OAuthClientDetails {
-  clientId: string;
-  clientSecret?: string;
-  clientName: string;
-  redirectUris: string[];
-  grantTypes: string[];
-  responseTypes: string[];
-  scope?: string;
-  clientUri?: string;
-  logoUri?: string;
-  tosUri?: string;
-  policyUri?: string;
-  createdAt: string;
-  createdByDid: string;
-}
-
-export interface ListOAuthClientsResponse {
-  clients: OAuthClientDetails[];
-}
-
-export interface UpdateOAuthClientRequest {
-  clientId: string;
-  clientName?: string;
-  redirectUris?: string[];
-  scope?: string;
-  clientUri?: string;
-  logoUri?: string;
-  tosUri?: string;
-  policyUri?: string;
-}
-
-export interface DeleteOAuthClientResponse {
-  success: boolean;
-  message: string;
-}
-
-export interface OAuthOperationError {
-  success: false;
-  message: string;
-}
 
 export type AppBskyGraphDefsListPurpose =
   | "app.bsky.graph.defs#modlist"
···
   | "createdAt"
   | "expiresAt";
 
+export interface NetworkSlicesSliceSyncUserCollectionsInput {
+  slice: string;
+  timeoutSeconds?: number;
+}
+
+export interface NetworkSlicesSliceSyncUserCollectionsOutput {
+  reposProcessed: number;
+  recordsSynced: number;
+  timedOut: boolean;
+}
+
 export interface NetworkSlicesSliceDefsSliceView {
   uri: string;
   cid: string;
···
   count: number;
 }
 
+export interface NetworkSlicesSliceGetSparklinesInput {
+  slices: string[];
+  interval?: string;
+  duration?: string;
+}
+
+export interface NetworkSlicesSliceGetSparklinesOutput {
+  sparklines: NetworkSlicesSliceGetSparklines["SparklineEntry"][];
+}
+
+export interface NetworkSlicesSliceGetSparklinesSparklineEntry {
+  /** AT-URI of the slice */
+  sliceUri: string;
+  /** Array of sparkline data points */
+  points: NetworkSlicesSliceDefs["SparklinePoint"][];
+}
+
+export interface NetworkSlicesSliceGetJobLogsParams {
+  jobId: string;
+  limit?: number;
+}
+
+export interface NetworkSlicesSliceGetJobLogsOutput {
+  logs: NetworkSlicesSliceGetJobLogs["LogEntry"][];
+}
+
+export interface NetworkSlicesSliceGetJobLogsLogEntry {
+  /** Log entry ID */
+  id: number;
+  /** When the log entry was created */
+  createdAt: string;
+  /** Type of log entry */
+  logType: string;
+  /** UUID of related job if applicable */
+  jobId?: string;
+  /** DID of related user if applicable */
+  userDid?: string;
+  /** AT-URI of related slice if applicable */
+  sliceUri?: string;
+  /** Log level */
+  level: string;
+  /** Log message */
+  message: string;
+  /** Additional metadata associated with the log entry */
+  metadata?: unknown;
+}
+
+export interface NetworkSlicesSliceGetJetstreamStatusOutput {
+  connected: boolean;
+}
+
 export interface NetworkSlicesSlice {
   /** Name of the slice */
   name: string;
···
 
 export type NetworkSlicesSliceSortFields = "name" | "domain" | "createdAt";
 
+export interface NetworkSlicesSliceGetJobStatusParams {
+  jobId: string;
+}
+
+export type NetworkSlicesSliceGetJobStatusOutput =
+  NetworkSlicesSliceGetJobStatus["JobStatus"];
+
+export interface NetworkSlicesSliceGetJobStatusJobStatus {
+  /** UUID of the job */
+  jobId: string;
+  /** Current status of the job */
+  status: string;
+  /** When the job was created */
+  createdAt: string;
+  /** When the job started executing */
+  startedAt?: string;
+  /** When the job completed */
+  completedAt?: string;
+  /** Job result if completed successfully */
+  result?: NetworkSlicesSliceGetJobStatus["SyncJobResult"];
+  /** Error message if job failed */
+  error?: string;
+  /** Number of times the job has been retried */
+  retryCount: number;
+}
+
+export interface NetworkSlicesSliceGetJobStatusSyncJobResult {
+  /** Whether the sync job completed successfully */
+  success: boolean;
+  /** Total number of records synced */
+  totalRecords: number;
+  /** List of collection NSIDs that were synced */
+  collectionsSynced: string[];
+  /** Number of repositories processed */
+  reposProcessed: number;
+  /** Human-readable message about the job completion */
+  message: string;
+}
+
+export interface NetworkSlicesSliceGetActorsInput {
+  slice: string;
+  limit?: number;
+  cursor?: string;
+  where?: unknown;
+}
+
+export interface NetworkSlicesSliceGetActorsOutput {
+  actors: NetworkSlicesSliceGetActors["Actor"][];
+  cursor?: string;
+}
+
+export interface NetworkSlicesSliceGetActorsActor {
+  /** Decentralized identifier of the actor */
+  did: string;
+  /** Human-readable handle of the actor */
+  handle?: string;
+  /** AT-URI of the slice this actor is indexed in */
+  sliceUri: string;
+  /** When this actor was indexed */
+  indexedAt: string;
+}
+
+export interface NetworkSlicesSliceDeleteOAuthClientInput {
+  clientId: string;
+}
+
+export interface NetworkSlicesSliceDeleteOAuthClientOutput {
+  message: string;
+}
+
+export interface NetworkSlicesSliceCreateOAuthClientInput {
+  sliceUri: string;
+  clientName: string;
+  redirectUris: string[];
+  grantTypes?: string[];
+  responseTypes?: string[];
+  scope?: string;
+  clientUri?: string;
+  logoUri?: string;
+  tosUri?: string;
+  policyUri?: string;
+}
+
+export type NetworkSlicesSliceCreateOAuthClientOutput =
+  NetworkSlicesSliceGetOAuthClients["OauthClientDetails"];
+
+export interface NetworkSlicesSliceGetJetstreamLogsParams {
+  slice?: string;
+  limit?: number;
+}
+
+export interface NetworkSlicesSliceGetJetstreamLogsOutput {
+  logs: NetworkSlicesSliceGetJobLogs["LogEntry"][];
+}
+
+export interface NetworkSlicesSliceGetSliceRecordsInput {
+  slice: string;
+  limit?: number;
+  cursor?: string;
+  where?: unknown;
+  sortBy?: unknown;
+}
+
+export interface NetworkSlicesSliceGetSliceRecordsOutput {
+  records: NetworkSlicesSliceGetSliceRecords["IndexedRecord"][];
+  cursor?: string;
+}
+
+export interface NetworkSlicesSliceGetSliceRecordsIndexedRecord {
+  /** AT-URI of the record */
+  uri: string;
+  /** Content identifier of the record */
+  cid: string;
+  /** DID of the record creator */
+  did: string;
+  /** NSID of the collection this record belongs to */
+  collection: string;
+  /** The record value/content */
+  value: unknown;
+  /** When this record was indexed */
+  indexedAt: string;
+}
+
+export interface NetworkSlicesSliceStartSyncInput {
+  slice: string;
+  collections?: string[];
+  externalCollections?: string[];
+  repos?: string[];
+  limitPerRepo?: number;
+  skipValidation?: boolean;
+}
+
+export interface NetworkSlicesSliceStartSyncOutput {
+  jobId: string;
+  message: string;
+}
+
+export interface NetworkSlicesSliceGetJobHistoryParams {
+  userDid: string;
+  sliceUri: string;
+  limit?: number;
+}
+
+export type NetworkSlicesSliceGetJobHistoryOutput =
+  NetworkSlicesSliceGetJobStatus["JobStatus"][];
+
+export interface NetworkSlicesSliceStatsParams {
+  slice: string;
+}
+
+export interface NetworkSlicesSliceStatsOutput {
+  collections: string[];
+  collectionStats: NetworkSlicesSliceStats["CollectionStats"][];
+  totalLexicons: number;
+  totalRecords: number;
+  totalActors: number;
+}
+
+export interface NetworkSlicesSliceStatsCollectionStats {
+  /** Collection NSID */
+  collection: string;
+  /** Number of records in this collection */
+  recordCount: number;
+  /** Number of unique actors with records in this collection */
+  uniqueActors: number;
+}
+
+export interface NetworkSlicesSliceUpdateOAuthClientInput {
+  clientId: string;
+  clientName?: string;
+  redirectUris?: string[];
+  scope?: string;
+  clientUri?: string;
+  logoUri?: string;
+  tosUri?: string;
+  policyUri?: string;
+}
+
+export type NetworkSlicesSliceUpdateOAuthClientOutput =
+  NetworkSlicesSliceGetOAuthClients["OauthClientDetails"];
+
+export interface NetworkSlicesSliceGetOAuthClientsParams {
+  slice: string;
+}
+
+export interface NetworkSlicesSliceGetOAuthClientsOutput {
+  clients: NetworkSlicesSliceGetOAuthClients["OauthClientDetails"][];
+}
+
+export interface NetworkSlicesSliceGetOAuthClientsOauthClientDetails {
+  /** OAuth client ID */
+  clientId: string;
+  /** OAuth client secret (only returned on creation) */
+  clientSecret?: string;
+  /** Human-readable name of the OAuth client */
+  clientName: string;
+  /** Allowed redirect URIs for OAuth flow */
+  redirectUris: string[];
+  /** Allowed OAuth grant types */
+  grantTypes: string[];
+  /** Allowed OAuth response types */
+  responseTypes: string[];
+  /** OAuth scope */
+  scope?: string;
+  /** URI of the client application */
+  clientUri?: string;
+  /** URI of the client logo */
+  logoUri?: string;
+  /** URI of the terms of service */
+  tosUri?: string;
+  /** URI of the privacy policy */
+  policyUri?: string;
+  /** When the OAuth client was created */
+  createdAt: string;
+  /** DID of the user who created this client */
+  createdByDid: string;
+}
+
 export interface NetworkSlicesLexicon {
   /** Namespaced identifier for the lexicon */
   nsid: string;
···
 export interface NetworkSlicesSliceDefs {
   readonly SliceView: NetworkSlicesSliceDefsSliceView;
   readonly SparklinePoint: NetworkSlicesSliceDefsSparklinePoint;
+}
+
+export interface NetworkSlicesSliceGetSparklines {
+  readonly SparklineEntry: NetworkSlicesSliceGetSparklinesSparklineEntry;
+}
+
+export interface NetworkSlicesSliceGetJobLogs {
+  readonly LogEntry: NetworkSlicesSliceGetJobLogsLogEntry;
+}
+
+export interface NetworkSlicesSliceGetJobStatus {
+  readonly JobStatus: NetworkSlicesSliceGetJobStatusJobStatus;
+  readonly SyncJobResult: NetworkSlicesSliceGetJobStatusSyncJobResult;
+}
+
+export interface NetworkSlicesSliceGetActors {
+  readonly Actor: NetworkSlicesSliceGetActorsActor;
+}
+
+export interface NetworkSlicesSliceGetSliceRecords {
+  readonly IndexedRecord: NetworkSlicesSliceGetSliceRecordsIndexedRecord;
+}
+
+export interface NetworkSlicesSliceStats {
+  readonly CollectionStats: NetworkSlicesSliceStatsCollectionStats;
+}
+
+export interface NetworkSlicesSliceGetOAuthClients {
+  readonly OauthClientDetails:
+    NetworkSlicesSliceGetOAuthClientsOauthClientDetails;
 }
 
 export interface NetworkSlicesActorDefs {
···
     return await this.client.deleteRecord("network.slices.slice", rkey);
   }
 
-  async stats(params: SliceStatsParams): Promise<SliceStatsOutput> {
-    return await this.client.makeRequest<SliceStatsOutput>(
-      "network.slices.slice.stats",
-      "POST",
-      params,
-    );
+  async syncUserCollections(
+    input: NetworkSlicesSliceSyncUserCollectionsInput,
+  ): Promise<NetworkSlicesSliceSyncUserCollectionsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceSyncUserCollectionsOutput
+    >("network.slices.slice.syncUserCollections", "POST", input);
   }
 
   async getSparklines(
-    params: GetSparklinesParams,
-  ): Promise<GetSparklinesOutput> {
-    return await this.client.makeRequest<GetSparklinesOutput>(
+    input: NetworkSlicesSliceGetSparklinesInput,
+  ): Promise<NetworkSlicesSliceGetSparklinesOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetSparklinesOutput>(
       "network.slices.slice.getSparklines",
       "POST",
-      params,
+      input,
     );
   }
 
-  async getSliceRecords<T = Record<string, unknown>>(
-    params: Omit<SliceLevelRecordsParams<T>, "slice">,
-  ): Promise<SliceRecordsOutput<T>> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: Record<string, unknown> = params?.where
-      ? { ...params.where }
-      : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.client.sliceUri,
-    };
-    return await this.client.makeRequest<SliceRecordsOutput<T>>(
-      "network.slices.slice.getSliceRecords",
-      "POST",
-      requestParams,
-    );
-  }
-
-  async getActors(params?: GetActorsParams): Promise<GetActorsResponse> {
-    const requestParams = { ...params, slice: this.client.sliceUri };
-    return await this.client.makeRequest<GetActorsResponse>(
-      "network.slices.slice.getActors",
-      "POST",
-      requestParams,
+  async getJobLogs(
+    params?: NetworkSlicesSliceGetJobLogsParams,
+  ): Promise<NetworkSlicesSliceGetJobLogsOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetJobLogsOutput>(
+      "network.slices.slice.getJobLogs",
+      "GET",
+      params,
     );
   }
 
-  async startSync(params: BulkSyncParams): Promise<SyncJobResponse> {
-    const requestParams = { ...params, slice: this.client.sliceUri };
-    return await this.client.makeRequest<SyncJobResponse>(
-      "network.slices.slice.startSync",
-      "POST",
-      requestParams,
-    );
+  async getJetstreamStatus(): Promise<
+    NetworkSlicesSliceGetJetstreamStatusOutput
+  > {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetJetstreamStatusOutput
+    >("network.slices.slice.getJetstreamStatus", "GET", {});
   }
 
-  async getJobStatus(params: GetJobStatusParams): Promise<JobStatus> {
-    return await this.client.makeRequest<JobStatus>(
+  async getJobStatus(
+    params?: NetworkSlicesSliceGetJobStatusParams,
+  ): Promise<NetworkSlicesSliceGetJobStatusOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetJobStatusOutput>(
       "network.slices.slice.getJobStatus",
       "GET",
       params,
     );
   }
 
-  async getJobHistory(
-    params: GetJobHistoryParams,
-  ): Promise<GetJobHistoryResponse> {
-    return await this.client.makeRequest<GetJobHistoryResponse>(
-      "network.slices.slice.getJobHistory",
-      "GET",
-      params,
+  async getActors(
+    input: NetworkSlicesSliceGetActorsInput,
+  ): Promise<NetworkSlicesSliceGetActorsOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetActorsOutput>(
+      "network.slices.slice.getActors",
+      "POST",
+      input,
     );
   }
 
-  async getJobLogs(params: GetJobLogsParams): Promise<GetJobLogsResponse> {
-    return await this.client.makeRequest<GetJobLogsResponse>(
-      "network.slices.slice.getJobLogs",
-      "GET",
-      params,
-    );
+  async deleteOAuthClient(
+    input: NetworkSlicesSliceDeleteOAuthClientInput,
+  ): Promise<NetworkSlicesSliceDeleteOAuthClientOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceDeleteOAuthClientOutput
+    >("network.slices.slice.deleteOAuthClient", "POST", input);
   }
 
-  async getJetstreamStatus(): Promise<JetstreamStatusResponse> {
-    return await this.client.makeRequest<JetstreamStatusResponse>(
-      "network.slices.slice.getJetstreamStatus",
-      "GET",
-    );
+  async createOAuthClient(
+    input: NetworkSlicesSliceCreateOAuthClientInput,
+  ): Promise<NetworkSlicesSliceCreateOAuthClientOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceCreateOAuthClientOutput
+    >("network.slices.slice.createOAuthClient", "POST", input);
   }
 
   async getJetstreamLogs(
-    params: GetJetstreamLogsParams,
-  ): Promise<GetJetstreamLogsResponse> {
-    const requestParams = { ...params, slice: this.client.sliceUri };
-    return await this.client.makeRequest<GetJetstreamLogsResponse>(
-      "network.slices.slice.getJetstreamLogs",
-      "GET",
-      requestParams,
-    );
+    params?: NetworkSlicesSliceGetJetstreamLogsParams,
+  ): Promise<NetworkSlicesSliceGetJetstreamLogsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetJetstreamLogsOutput
+    >("network.slices.slice.getJetstreamLogs", "GET", params);
+  }
+
+  async getSliceRecords(
+    input: NetworkSlicesSliceGetSliceRecordsInput,
+  ): Promise<NetworkSlicesSliceGetSliceRecordsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetSliceRecordsOutput
+    >("network.slices.slice.getSliceRecords", "POST", input);
   }
 
-  async syncUserCollections(
-    params?: SyncUserCollectionsRequest,
-  ): Promise<SyncUserCollectionsResult> {
-    const requestParams = { slice: this.client.sliceUri, ...params };
-    return await this.client.makeRequest<SyncUserCollectionsResult>(
-      "network.slices.slice.syncUserCollections",
+  async startSync(
+    input: NetworkSlicesSliceStartSyncInput,
+  ): Promise<NetworkSlicesSliceStartSyncOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceStartSyncOutput>(
+      "network.slices.slice.startSync",
       "POST",
-      requestParams,
+      input,
     );
   }
 
-  async createOAuthClient(
-    params: CreateOAuthClientRequest,
-  ): Promise<OAuthClientDetails | OAuthOperationError> {
-    const requestParams = { ...params, sliceUri: this.client.sliceUri };
-    return await this.client.makeRequest<
-      OAuthClientDetails | OAuthOperationError
-    >("network.slices.slice.createOAuthClient", "POST", requestParams);
+  async getJobHistory(
+    params?: NetworkSlicesSliceGetJobHistoryParams,
+  ): Promise<NetworkSlicesSliceGetJobHistoryOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceGetJobHistoryOutput>(
+      "network.slices.slice.getJobHistory",
+      "GET",
+      params,
+    );
   }
 
-  async getOAuthClients(): Promise<ListOAuthClientsResponse> {
-    const requestParams = { slice: this.client.sliceUri };
-    return await this.client.makeRequest<ListOAuthClientsResponse>(
-      "network.slices.slice.getOAuthClients",
+  async stats(
+    params?: NetworkSlicesSliceStatsParams,
+  ): Promise<NetworkSlicesSliceStatsOutput> {
+    return await this.client.makeRequest<NetworkSlicesSliceStatsOutput>(
+      "network.slices.slice.stats",
       "GET",
-      requestParams,
+      params,
     );
   }
 
   async updateOAuthClient(
-    params: UpdateOAuthClientRequest,
-  ): Promise<OAuthClientDetails | OAuthOperationError> {
-    const requestParams = { ...params, sliceUri: this.client.sliceUri };
+    input: NetworkSlicesSliceUpdateOAuthClientInput,
+  ): Promise<NetworkSlicesSliceUpdateOAuthClientOutput> {
     return await this.client.makeRequest<
-      OAuthClientDetails | OAuthOperationError
-    >("network.slices.slice.updateOAuthClient", "POST", requestParams);
+      NetworkSlicesSliceUpdateOAuthClientOutput
+    >("network.slices.slice.updateOAuthClient", "POST", input);
   }
 
-  async deleteOAuthClient(
-    clientId: string,
-  ): Promise<DeleteOAuthClientResponse> {
-    return await this.client.makeRequest<DeleteOAuthClientResponse>(
-      "network.slices.slice.deleteOAuthClient",
-      "POST",
-      { clientId },
-    );
+  async getOAuthClients(
+    params?: NetworkSlicesSliceGetOAuthClientsParams,
+  ): Promise<NetworkSlicesSliceGetOAuthClientsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceGetOAuthClientsOutput
+    >("network.slices.slice.getOAuthClients", "GET", params);
   }
 }
 

packages/client/src/mod.ts

···
 }
 
 export interface CountRecordsResponse {
-  success: boolean;
   count: number;
-  message?: string;
 }
 
 export interface GetRecordParams {
···
 }
 
 export interface SliceRecordsOutput<T = Record<string, unknown>> {
-  success: boolean;
   records: IndexedRecord<T>[];
   cursor?: string;
-  message?: string;
 }
 
 // Blob upload interfaces
···
 
     if (httpMethod === "GET" && params) {
       const searchParams = new URLSearchParams();
-      Object.entries(params).forEach(([key, value]) => {
+      Object.entries(params as Record<string, unknown>).forEach(([key, value]) => {
         if (value !== undefined && value !== null) {
           searchParams.append(key, String(value));
         }
···
 
       try {
         const errorBody = await response.json();
-        if (errorBody?.message) {
-          errorMessage += ` - ${errorBody.message}`;
+        // XRPC-style error format: { error: "ErrorName", message: "details" }
+        if (errorBody?.error && errorBody?.message) {
+          errorMessage = `${errorBody.error}: ${errorBody.message}`;
+        } else if (errorBody?.message) {
+          errorMessage = errorBody.message;
         } else if (errorBody?.error) {
-          errorMessage += ` - ${errorBody.error}`;
+          errorMessage = errorBody.error;
         }
       } catch {
         // If we can't parse the response body, just use the status message
···
       let errorMessage = `Blob upload failed: ${response.status} ${response.statusText}`;
       try {
         const errorBody = await response.json();
-        if (errorBody?.message) {
-          errorMessage += ` - ${errorBody.message}`;
+        // XRPC-style error format: { error: "ErrorName", message: "details" }
+        if (errorBody?.error && errorBody?.message) {
+          errorMessage = `${errorBody.error}: ${errorBody.message}`;
+        } else if (errorBody?.message) {
+          errorMessage = errorBody.message;
         } else if (errorBody?.error) {
-          errorMessage += ` - ${errorBody.error}`;
+          errorMessage = errorBody.error;
         }
       } catch {
         // If we can't parse the response body, just use the status message

packages/codegen/src/client.ts

···
 import { nsidToPascalCase, capitalizeFirst } from "./mod.ts";
 
 interface NestedStructure {
-  [key: string]: NestedStructure | string | undefined;
+  [key: string]: NestedStructure | string | QueryProcedureInfo[] | undefined;
   _recordType?: string;
   _collectionPath?: string;
+  _queryProcedures?: QueryProcedureInfo[];
+}
+
+interface QueryProcedureInfo {
+  nsid: string;
+  type: "query" | "procedure";
+  methodName: string;
+  parametersType?: string;
+  inputType?: string;
+  outputType?: string;
 }
 
 interface PropertyInfo {
···
 
 export function generateClient(
   sourceFile: SourceFile,
-  lexicons: Lexicon[],
-  excludeSlicesClient: boolean
+  lexicons: Lexicon[]
 ): void {
   // Create nested structure from lexicons
   const nestedStructure: NestedStructure = {};
 
   for (const lexicon of lexicons) {
     if (lexicon.definitions && typeof lexicon.definitions === "object") {
-      for (const [, defValue] of Object.entries(lexicon.definitions)) {
-        if (defValue.type === "record" && defValue.record) {
-          const parts = lexicon.id.split(".");
-          let current = nestedStructure;
+      // Check if this lexicon has any records, queries, or procedures
+      const hasRecordsOrEndpoints = Object.values(lexicon.definitions).some(
+        (defValue) =>
+          (defValue.type === "record" && defValue.record) ||
+          defValue.type === "query" ||
+          defValue.type === "procedure"
+      );
+
+      // Only build nested structure for lexicons that have records
+      if (hasRecordsOrEndpoints) {
+        for (const [_, defValue] of Object.entries(lexicon.definitions)) {
+          if (defValue.type === "record" && defValue.record) {
+            const parts = lexicon.id.split(".");
+            let current = nestedStructure;
 
-          // Build nested structure
-          for (const part of parts) {
-            if (!current[part]) {
-              current[part] = {};
+            // Build nested structure
+            for (const part of parts) {
+              if (!current[part]) {
+                current[part] = {};
+              }
+              current = current[part] as NestedStructure;
             }
-            current = current[part] as NestedStructure;
+
+            // Add the record interface name and store collection path
+            current._recordType = nsidToPascalCase(lexicon.id);
+            current._collectionPath = lexicon.id;
           }
+        }
+      }
+    }
+  }
 
-          // Add the record interface name and store collection path
-          current._recordType = nsidToPascalCase(lexicon.id);
-          current._collectionPath = lexicon.id;
+  // Add query/procedure methods to the appropriate parent clients
+  function addQueryProcedureMethods(
+    obj: NestedStructure,
+    lexicons: Lexicon[]
+  ): void {
+    // Group query/procedure endpoints by their parent collection path
+    const endpointsByParent = new Map<string, QueryProcedureInfo[]>();
+
+    for (const lexicon of lexicons) {
+      if (lexicon.definitions && typeof lexicon.definitions === "object") {
+        for (const [_, defValue] of Object.entries(lexicon.definitions)) {
+          if (defValue.type === "query" || defValue.type === "procedure") {
+            const parts = lexicon.id.split(".");
+            const methodName = parts[parts.length - 1];
+
+            // Find the parent collection by removing the method name
+            // e.g., "network.slices.slice.getJobStatus" -> "network.slices.slice"
+            const parentPath = parts.slice(0, -1).join(".");
+
+            const queryProcedureInfo: QueryProcedureInfo = {
+              nsid: lexicon.id,
+              type: defValue.type as "query" | "procedure",
+              methodName,
+              parametersType:
+                defValue.parameters?.properties &&
+                Object.keys(defValue.parameters.properties).length > 0
+                  ? `${nsidToPascalCase(lexicon.id)}Params`
+                  : undefined,
+              inputType: defValue.input
+                ? `${nsidToPascalCase(lexicon.id)}Input`
+                : undefined,
+              outputType: defValue.output
+                ? `${nsidToPascalCase(lexicon.id)}Output`
+                : undefined,
+            };
+
+            if (!endpointsByParent.has(parentPath)) {
+              endpointsByParent.set(parentPath, []);
+            }
+            endpointsByParent.get(parentPath)!.push(queryProcedureInfo);
+          }
         }
       }
     }
+
+    // Add endpoints to their respective parent clients
+    function addEndpointsToNode(
+      current: NestedStructure,
+      path: string[],
+      fullPath: string
+    ): void {
+      if (path.length === 0) {
+        // We've reached the target node, add the endpoints if this has a record type
+        const endpoints = endpointsByParent.get(fullPath);
+        if (endpoints && current._recordType) {
+          if (!current._queryProcedures) {
+            current._queryProcedures = [];
+          }
+          current._queryProcedures.push(...endpoints);
+        }
+        return;
+      }
+
+      const [head, ...tail] = path;
+      if (current[head]) {
+        addEndpointsToNode(current[head] as NestedStructure, tail, fullPath);
+      }
+    }
+
+    // Add endpoints to their parent nodes
+    for (const parentPath of endpointsByParent.keys()) {
+      const pathParts = parentPath.split(".");
+      addEndpointsToNode(obj, pathParts, parentPath);
+    }
   }
+
+  // Add query/procedure methods before generating classes
+  addQueryProcedureMethods(nestedStructure, lexicons);
 
   // Generate nested class structure
   function generateNestedClass(
···
         });
       } else if (key === "_collectionPath") {
         collectionPath = value as string;
+      } else if (key === "_queryProcedures") {
+        // Add query and procedure methods
+        const queryProcedures = value as QueryProcedureInfo[];
+        for (const qp of queryProcedures) {
+          if (qp.type === "query") {
+            // Generate query method (GET)
+            const parameters = [];
+            if (qp.parametersType) {
+              parameters.push({
+                name: "params",
+                type: qp.parametersType,
+                hasQuestionToken: true,
+              });
+            }
+            methods.push({
+              name: qp.methodName,
+              parameters,
+              returnType: `Promise<${qp.outputType || "void"}>`,
+            });
+          } else if (qp.type === "procedure") {
+            // Generate procedure method (POST)
+            const parameters = [];
+            if (qp.inputType) {
+              parameters.push({
+                name: "input",
+                type: qp.inputType,
+              });
+            } else if (qp.parametersType) {
+              parameters.push({
+                name: "params",
+                type: qp.parametersType,
+              });
+            }
+            methods.push({
+              name: qp.methodName,
+              parameters,
+              returnType: `Promise<${qp.outputType || "void"}>`,
+            });
+          }
+        }
       } else if (typeof value === "object" && Object.keys(value).length > 0) {
         // Add nested property with PascalCase class name
         const nestedClassName = `${capitalizeFirst(key)}${className}`;
···
           methodDecl.addStatements([
             `return await ${clientRef}.countRecords('${collectionPath}', params);`,
           ]);
+        } else {
+          // Handle query and procedure methods
+          const queryProcedures = obj._queryProcedures || [];
+          const matchingQP = queryProcedures.find(
+            (qp) => qp.methodName === method.name
+          );
+
+          if (matchingQP) {
+            if (matchingQP.type === "query") {
+              // Query methods use GET with query parameters
+              const paramArg = method.parameters.length > 0 ? "params" : "{}";
+              methodDecl.addStatements([
+                `return await ${clientRef}.makeRequest<${
+                  matchingQP.outputType || "void"
+                }>('${matchingQP.nsid}', 'GET', ${paramArg});`,
+              ]);
+            } else if (matchingQP.type === "procedure") {
+              // Procedure methods use POST with body
+              const paramArg =
+                method.parameters.length > 0 ? method.parameters[0].name : "{}";
+              methodDecl.addStatements([
+                `return await ${clientRef}.makeRequest<${
+                  matchingQP.outputType || "void"
+                }>('${matchingQP.nsid}', 'POST', ${paramArg});`,
+              ]);
+            }
+          }
         }
-      }
-
-      // Add network.slices.slice specific methods when not excluding slices client
-      if (
-        !excludeSlicesClient &&
-        currentPath.length === 3 &&
-        currentPath[0] === "network" &&
-        currentPath[1] === "slices" &&
-        currentPath[2] === "slice"
-      ) {
-        classDeclaration.addMethod({
-          name: "stats",
-          parameters: [{ name: "params", type: "SliceStatsParams" }],
-          returnType: "Promise<SliceStatsOutput>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<SliceStatsOutput>('network.slices.slice.stats', 'POST', params);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getSparklines",
-          parameters: [{ name: "params", type: "GetSparklinesParams" }],
-          returnType: "Promise<GetSparklinesOutput>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<GetSparklinesOutput>('network.slices.slice.getSparklines', 'POST', params);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getSliceRecords",
-          typeParameters: [{ name: "T", default: "Record<string, unknown>" }],
-          parameters: [
-            {
-              name: "params",
-              type: "Omit<SliceLevelRecordsParams<T>, 'slice'>",
-            },
-          ],
-          returnType: "Promise<SliceRecordsOutput<T>>",
-          isAsync: true,
-          statements: [
-            `// Combine where and orWhere into the expected backend format`,
-            `const whereClause: Record<string, unknown> = params?.where ? { ...params.where } : {};`,
-            `if (params?.orWhere) {`,
-            `  whereClause.$or = params.orWhere;`,
-            `}`,
-            `const requestParams = {`,
-            `  ...params,`,
-            `  where: Object.keys(whereClause).length > 0 ? whereClause : undefined,`,
-            `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
-            `  slice: this.client.sliceUri`,
-            `};`,
-            `return await this.client.makeRequest<SliceRecordsOutput<T>>('network.slices.slice.getSliceRecords', 'POST', requestParams);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getActors",
-          parameters: [
-            { name: "params", type: "GetActorsParams", hasQuestionToken: true },
-          ],
-          returnType: "Promise<GetActorsResponse>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { ...params, slice: this.client.sliceUri };`,
-            `return await this.client.makeRequest<GetActorsResponse>('network.slices.slice.getActors', 'POST', requestParams);`,
-          ],
-        });
-
-        // Add sync methods
-        classDeclaration.addMethod({
-          name: "startSync",
-          parameters: [{ name: "params", type: "BulkSyncParams" }],
-          returnType: "Promise<SyncJobResponse>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { ...params, slice: this.client.sliceUri };`,
-            `return await this.client.makeRequest<SyncJobResponse>('network.slices.slice.startSync', 'POST', requestParams);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getJobStatus",
-          parameters: [{ name: "params", type: "GetJobStatusParams" }],
-          returnType: "Promise<JobStatus>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<JobStatus>('network.slices.slice.getJobStatus', 'GET', params);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getJobHistory",
-          parameters: [{ name: "params", type: "GetJobHistoryParams" }],
-          returnType: "Promise<GetJobHistoryResponse>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<GetJobHistoryResponse>('network.slices.slice.getJobHistory', 'GET', params);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getJobLogs",
-          parameters: [{ name: "params", type: "GetJobLogsParams" }],
-          returnType: "Promise<GetJobLogsResponse>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<GetJobLogsResponse>('network.slices.slice.getJobLogs', 'GET', params);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getJetstreamStatus",
-          returnType: "Promise<JetstreamStatusResponse>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<JetstreamStatusResponse>('network.slices.slice.getJetstreamStatus', 'GET');`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getJetstreamLogs",
-          parameters: [{ name: "params", type: "GetJetstreamLogsParams" }],
-          returnType: "Promise<GetJetstreamLogsResponse>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { ...params, slice: this.client.sliceUri };`,
-            `return await this.client.makeRequest<GetJetstreamLogsResponse>('network.slices.slice.getJetstreamLogs', 'GET', requestParams);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "syncUserCollections",
-          parameters: [
-            {
-              name: "params",
-              type: "SyncUserCollectionsRequest",
-              hasQuestionToken: true,
-            },
-          ],
-          returnType: "Promise<SyncUserCollectionsResult>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { slice: this.client.sliceUri, ...params };`,
-            `return await this.client.makeRequest<SyncUserCollectionsResult>('network.slices.slice.syncUserCollections', 'POST', requestParams);`,
-          ],
-        });
-
-        // Add OAuth client management methods
-        classDeclaration.addMethod({
-          name: "createOAuthClient",
-          parameters: [{ name: "params", type: "CreateOAuthClientRequest" }],
-          returnType: "Promise<OAuthClientDetails | OAuthOperationError>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { ...params, sliceUri: this.client.sliceUri };`,
-            `return await this.client.makeRequest<OAuthClientDetails | OAuthOperationError>('network.slices.slice.createOAuthClient', 'POST', requestParams);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "getOAuthClients",
-          returnType: "Promise<ListOAuthClientsResponse>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { slice: this.client.sliceUri };`,
-            `return await this.client.makeRequest<ListOAuthClientsResponse>('network.slices.slice.getOAuthClients', 'GET', requestParams);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "updateOAuthClient",
-          parameters: [{ name: "params", type: "UpdateOAuthClientRequest" }],
-          returnType: "Promise<OAuthClientDetails | OAuthOperationError>",
-          isAsync: true,
-          statements: [
-            `const requestParams = { ...params, sliceUri: this.client.sliceUri };`,
-            `return await this.client.makeRequest<OAuthClientDetails | OAuthOperationError>('network.slices.slice.updateOAuthClient', 'POST', requestParams);`,
-          ],
-        });
-
-        classDeclaration.addMethod({
-          name: "deleteOAuthClient",
-          parameters: [{ name: "clientId", type: "string" }],
-          returnType: "Promise<DeleteOAuthClientResponse>",
-          isAsync: true,
-          statements: [
-            `return await this.client.makeRequest<DeleteOAuthClientResponse>('network.slices.slice.deleteOAuthClient', 'POST', { clientId });`,
-          ],
-        });
       }
     }
   }

packages/codegen/src/interfaces.ts

···
 
 // Base interfaces are imported from @slices/client, only add network.slices specific interfaces
 function addBaseInterfaces(
+  _sourceFile: SourceFile
+): void {
+  // All interfaces are now generated from lexicons
+  // This function is kept for future extensibility if needed
+}
+
+// Generate interfaces for query and procedure parameters/input/output
+function generateQueryProcedureInterfaces(
   sourceFile: SourceFile,
-  excludeSlicesClient: boolean
+  lexicon: Lexicon,
+  defValue: LexiconDefinition,
+  lexicons: Lexicon[],
+  type: "query" | "procedure"
 ): void {
-  // Only generate network.slices specific interfaces when not excluding slices client
-  if (!excludeSlicesClient) {
-    // Codegen XRPC interfaces
+  const baseName = nsidToPascalCase(lexicon.id);
 
-    // Sync interfaces
-    sourceFile.addInterface({
-      name: "BulkSyncParams",
-      isExported: true,
-      properties: [
-        { name: "collections", type: "string[]", hasQuestionToken: true },
-        {
-          name: "externalCollections",
-          type: "string[]",
-          hasQuestionToken: true,
-        },
-        { name: "repos", type: "string[]", hasQuestionToken: true },
-        { name: "limitPerRepo", type: "number", hasQuestionToken: true },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "BulkSyncOutput",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        { name: "totalRecords", type: "number" },
-        { name: "collectionsSynced", type: "string[]" },
-        { name: "reposProcessed", type: "number" },
-        { name: "message", type: "string" },
-      ],
-    });
-
-    // Job queue interfaces
-    sourceFile.addInterface({
-      name: "SyncJobResponse",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        { name: "jobId", type: "string", hasQuestionToken: true },
-        { name: "message", type: "string" },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "SyncJobResult",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        { name: "totalRecords", type: "number" },
-        { name: "collectionsSynced", type: "string[]" },
-        { name: "reposProcessed", type: "number" },
-        { name: "message", type: "string" },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "JobStatus",
-      isExported: true,
-      properties: [
-        { name: "jobId", type: "string" },
-        { name: "status", type: "string" },
-        { name: "createdAt", type: "string" },
-        { name: "startedAt", type: "string", hasQuestionToken: true },
-        { name: "completedAt", type: "string", hasQuestionToken: true },
-        { name: "result", type: "SyncJobResult", hasQuestionToken: true },
-        { name: "error", type: "string", hasQuestionToken: true },
-        { name: "retryCount", type: "number" },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "GetJobStatusParams",
-      isExported: true,
-      properties: [{ name: "jobId", type: "string" }],
-    });
-
-    sourceFile.addInterface({
-      name: "GetJobHistoryParams",
-      isExported: true,
-      properties: [
-        { name: "userDid", type: "string" },
-        { name: "sliceUri", type: "string" },
-        { name: "limit", type: "number", hasQuestionToken: true },
-      ],
-    });
-
-    sourceFile.addTypeAlias({
-      name: "GetJobHistoryResponse",
-      isExported: true,
-      type: "JobStatus[]",
-    });
-
-    sourceFile.addInterface({
-      name: "GetJobLogsParams",
-      isExported: true,
-      properties: [
-        { name: "jobId", type: "string" },
-        { name: "limit", type: "number", hasQuestionToken: true },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "GetJobLogsResponse",
-      isExported: true,
-      properties: [{ name: "logs", type: "LogEntry[]" }],
-    });
-
-    sourceFile.addInterface({
-      name: "GetJetstreamLogsParams",
-      isExported: true,
-      properties: [{ name: "limit", type: "number", hasQuestionToken: true }],
-    });
-
-    sourceFile.addInterface({
-      name: "GetJetstreamLogsResponse",
-      isExported: true,
-      properties: [{ name: "logs", type: "LogEntry[]" }],
-    });
-
-    sourceFile.addInterface({
-      name: "LogEntry",
-      isExported: true,
-      properties: [
-        { name: "id", type: "number" },
-        { name: "createdAt", type: "string" },
-        { name: "logType", type: "string" },
-        { name: "jobId", type: "string", hasQuestionToken: true },
-        { name: "userDid", type: "string", hasQuestionToken: true },
-        { name: "sliceUri", type: "string", hasQuestionToken: true },
-        { name: "level", type: "string" },
-        { name: "message", type: "string" },
-        {
-          name: "metadata",
-          type: "Record<string, unknown>",
-          hasQuestionToken: true,
-        },
-      ],
-    });
-
-    // Sync user collections interfaces
-    sourceFile.addInterface({
-      name: "SyncUserCollectionsRequest",
-      isExported: true,
-      properties: [
-        { name: "slice", type: "string" },
-        { name: "timeoutSeconds", type: "number", hasQuestionToken: true },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "SyncUserCollectionsResult",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        { name: "reposProcessed", type: "number" },
-        { name: "recordsSynced", type: "number" },
-        { name: "timedOut", type: "boolean" },
-        { name: "message", type: "string" },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "JetstreamStatusResponse",
-      isExported: true,
-      properties: [
-        { name: "connected", type: "boolean" },
-        { name: "status", type: "string" },
-        { name: "error", type: "string", hasQuestionToken: true },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "CollectionStats",
-      isExported: true,
-      properties: [
-        { name: "collection", type: "string" },
-        { name: "recordCount", type: "number" },
-        { name: "uniqueActors", type: "number" },
-      ],
-    });
-
-    sourceFile.addInterface({
-      name: "SliceStatsParams",
-      isExported: true,
-      properties: [{ name: "slice", type: "string" }],
-    });
-
-    sourceFile.addInterface({
-      name: "SliceStatsOutput",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        { name: "collections", type: "string[]" },
-        { name: "collectionStats", type: "CollectionStats[]" },
-        { name: "totalLexicons", type: "number" },
-        { name: "totalRecords", type: "number" },
-        { name: "totalActors", type: "number" },
-        { name: "message", type: "string", hasQuestionToken: true },
-      ],
-    });
+  // Generate parameters interface if present and has properties
+  if (defValue.parameters?.properties && Object.keys(defValue.parameters.properties).length > 0) {
+    const interfaceName = `${baseName}Params`;
+    const properties = Object.entries(defValue.parameters.properties).map(
+      ([propName, propDef]) => ({
+        name: propName,
+        type: convertLexiconTypeToTypeScript(
+          propDef,
+          lexicon.id,
+          propName,
+          lexicons
+        ),
+        hasQuestionToken: !(defValue.parameters?.required || []).includes(propName),
+      })
+    );
 
     sourceFile.addInterface({
-      name: "GetSparklinesParams",
+      name: interfaceName,
       isExported: true,
-      properties: [
-        { name: "slices", type: "string[]" },
-        { name: "interval", type: "string", hasQuestionToken: true },
-        { name: "duration", type: "string", hasQuestionToken: true },
-      ],
+      properties,
     });
+  }
 
-    sourceFile.addInterface({
-      name: "GetSparklinesOutput",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        {
-          name: "sparklines",
-          type: `Record<string, NetworkSlicesSliceDefs["SparklinePoint"][]>`,
-        },
-        { name: "message", type: "string", hasQuestionToken: true },
-      ],
-    });
+  // Generate input interface for procedures
+  if (type === "procedure" && defValue.input?.schema) {
+    const interfaceName = `${baseName}Input`;
 
-    // OAuth client interfaces
-    sourceFile.addInterface({
-      name: "CreateOAuthClientRequest",
-      isExported: true,
-      properties: [
-        { name: "clientName", type: "string" },
-        { name: "redirectUris", type: "string[]" },
-        { name: "grantTypes", type: "string[]", hasQuestionToken: true },
-        { name: "responseTypes", type: "string[]", hasQuestionToken: true },
-        { name: "scope", type: "string", hasQuestionToken: true },
-        { name: "clientUri", type: "string", hasQuestionToken: true },
-        { name: "logoUri", type: "string", hasQuestionToken: true },
-        { name: "tosUri", type: "string", hasQuestionToken: true },
-        { name: "policyUri", type: "string", hasQuestionToken: true },
-      ],
-    });
+    if (defValue.input?.schema?.type === "object" && defValue.input.schema.properties) {
+      const properties = Object.entries(defValue.input.schema.properties).map(
+        ([propName, propDef]) => ({
+          name: propName,
+          type: convertLexiconTypeToTypeScript(
+            propDef,
+            lexicon.id,
+            propName,
+            lexicons
+          ),
+          hasQuestionToken: !((defValue.input?.schema?.required as string[]) || []).includes(propName),
+        })
+      );
 
-    sourceFile.addInterface({
-      name: "OAuthClientDetails",
-      isExported: true,
-      properties: [
-        { name: "clientId", type: "string" },
-        { name: "clientSecret", type: "string", hasQuestionToken: true },
-        { name: "clientName", type: "string" },
-        { name: "redirectUris", type: "string[]" },
-        { name: "grantTypes", type: "string[]" },
-        { name: "responseTypes", type: "string[]" },
-        { name: "scope", type: "string", hasQuestionToken: true },
-        { name: "clientUri", type: "string", hasQuestionToken: true },
-        { name: "logoUri", type: "string", hasQuestionToken: true },
-        { name: "tosUri", type: "string", hasQuestionToken: true },
-        { name: "policyUri", type: "string", hasQuestionToken: true },
-        { name: "createdAt", type: "string" },
-        { name: "createdByDid", type: "string" },
-      ],
-    });
+      sourceFile.addInterface({
+        name: interfaceName,
+        isExported: true,
+        properties,
+      });
+    }
+  }
 
-    sourceFile.addInterface({
-      name: "ListOAuthClientsResponse",
-      isExported: true,
-      properties: [{ name: "clients", type: "OAuthClientDetails[]" }],
-    });
+  // Generate output interface if present
+  if (defValue.output?.schema) {
+    const interfaceName = `${baseName}Output`;
 
-    sourceFile.addInterface({
-      name: "UpdateOAuthClientRequest",
-      isExported: true,
-      properties: [
-        { name: "clientId", type: "string" },
-        { name: "clientName", type: "string", hasQuestionToken: true },
-        { name: "redirectUris", type: "string[]", hasQuestionToken: true },
-        { name: "scope", type: "string", hasQuestionToken: true },
-        { name: "clientUri", type: "string", hasQuestionToken: true },
-        { name: "logoUri", type: "string", hasQuestionToken: true },
-        { name: "tosUri", type: "string", hasQuestionToken: true },
-        { name: "policyUri", type: "string", hasQuestionToken: true },
-      ],
-    });
+    if (defValue.output?.schema?.type === "object" && defValue.output.schema.properties) {
+      const properties = Object.entries(defValue.output.schema.properties).map(
+        ([propName, propDef]) => ({
+          name: propName,
+          type: convertLexiconTypeToTypeScript(
+            propDef,
+            lexicon.id,
+            propName,
+            lexicons
+          ),
+          hasQuestionToken: !((defValue.output?.schema?.required as string[]) || []).includes(propName),
+        })
+      );
 
-    sourceFile.addInterface({
-      name: "DeleteOAuthClientResponse",
-      isExported: true,
-      properties: [
-        { name: "success", type: "boolean" },
-        { name: "message", type: "string" },
-      ],
-    });
+      sourceFile.addInterface({
+        name: interfaceName,
+        isExported: true,
+        properties,
+      });
+    } else {
+      // Handle non-object output schemas (like refs) by creating a type alias
+      const outputType = convertLexiconTypeToTypeScript(
+        defValue.output.schema,
+        lexicon.id,
+        undefined,
+        lexicons
+      );
 
-    sourceFile.addInterface({
-      name: "OAuthOperationError",
-      isExported: true,
-      properties: [
-        { name: "success", type: "false" },
-        { name: "message", type: "string" },
-      ],
-    });
+      sourceFile.addTypeAlias({
+        name: interfaceName,
+        isExported: true,
+        type: outputType,
+      });
+    }
   }
 }
 
 export function generateInterfaces(
   sourceFile: SourceFile,
-  lexicons: Lexicon[],
-  excludeSlicesClient: boolean
+  lexicons: Lexicon[]
 ): void {
-  // Base interfaces are imported from @slices/client, only add network.slices specific interfaces
-  addBaseInterfaces(sourceFile, excludeSlicesClient);
+  // Base interfaces are imported from @slices/client, only add custom interfaces
+  addBaseInterfaces(sourceFile);
 
   // Generate type aliases for string fields with knownValues
   generateKnownValuesTypes(sourceFile, lexicons);
···
             break;
           case "token":
             generateTokenType(sourceFile, lexicon, defKey);
+            break;
+          case "query":
+            generateQueryProcedureInterfaces(
+              sourceFile,
+              lexicon,
+              defValue,
+              lexicons,
+              "query"
+            );
+            break;
+          case "procedure":
+            generateQueryProcedureInterfaces(
+              sourceFile,
+              lexicon,
+              defValue,
+              lexicons,
+              "procedure"
+            );
             break;
         }
       }

packages/codegen/src/mod.ts

···
   required?: string[];
 }
 
+export interface LexiconParameters {
+  type: "params";
+  properties?: Record<string, LexiconProperty>;
+  required?: string[];
+}
+
+export interface LexiconIO {
+  encoding: string;
+  schema?: LexiconProperty;
+}
+
 export interface LexiconDefinition {
   type: string;
+  description?: string;
+  // Record type fields
   record?: LexiconRecord;
+  key?: string;
+  // Query/Procedure fields
+  parameters?: LexiconParameters;
+  input?: LexiconIO;
+  output?: LexiconIO;
+  // Generic schema fields
   properties?: Record<string, LexiconProperty>;
   required?: string[];
   refs?: string[];
···
 
 export interface GenerateOptions {
   sliceUri: string;
-  excludeSlicesClient?: boolean;
 }
 
 // Normalize lexicons to use consistent property names
···
 
 export function generateHeaderComment(
   lexicons: Lexicon[],
-  usageExample: string,
-  excludeSlicesClient: boolean
+  usageExample: string
 ): string {
   return `// Generated TypeScript client for AT Protocol records
 // Generated at: ${new Date().toISOString().slice(0, 19).replace("T", " ")} UTC
···
 
 ${usageExample}
 
-${
-  excludeSlicesClient
-    ? 'import { SlicesClient, type RecordResponse, type GetRecordsResponse, type CountRecordsResponse, type GetRecordParams, type WhereCondition, type IndexedRecordFields, type SortField, type BlobRef, type AuthProvider } from "@slices/client";\nimport type { OAuthClient } from "@slices/oauth";'
-    : 'import { SlicesClient, type RecordResponse, type GetRecordsResponse, type CountRecordsResponse, type GetRecordParams, type WhereCondition, type IndexedRecordFields, type SortField, type GetActorsParams, type GetActorsResponse, type BlobRef, type SliceLevelRecordsParams, type SliceRecordsOutput, type AuthProvider } from "@slices/client";\nimport type { OAuthClient } from "@slices/oauth";'
-}
+import { SlicesClient, type RecordResponse, type GetRecordsResponse, type CountRecordsResponse, type GetRecordParams, type WhereCondition, type IndexedRecordFields, type SortField, type BlobRef, type AuthProvider } from "@slices/client";
+import type { OAuthClient } from "@slices/oauth";
 
 `;
 }
···
   );
   const headerComment = generateHeaderComment(
     normalizedLexicons,
-    usageExample,
-    options.excludeSlicesClient || false
+    usageExample
   );
 
   // Add header comment and imports to the source file first
···
   // Generate interfaces and client
   generateInterfaces(
     sourceFile,
-    normalizedLexicons,
-    options.excludeSlicesClient || false
+    normalizedLexicons
   );
   generateClient(
     sourceFile,
-    normalizedLexicons,
-    options.excludeSlicesClient || false
+    normalizedLexicons
   );
 
   // Get the generated code

packages/codegen/tests/client_test.ts

···
     },
   ];
 
-  generateClient(sourceFile, lexicons, true);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should create main AtProtoClient class
···
 
   // Should create nested class structure
   assertStringIncludes(result, "class ComClient");
-  assertStringIncludes(result, "class ExampleComClient");
+  assertStringIncludes(result, "class PostExampleComClient");
 
   // Should have nested properties
   assertStringIncludes(result, "readonly com: ComClient;");
-  assertStringIncludes(result, "readonly example: ExampleComClient;");
+  assertStringIncludes(result, "readonly post: PostExampleComClient;");
 
   // Should have OAuth client property
-  assertStringIncludes(result, "readonly oauth?: OAuthClient;");
+  assertStringIncludes(result, "readonly oauth?: OAuthClient | AuthProvider;");
 });
 
 Deno.test("generateClient - creates CRUD methods for records", () => {
···
     },
   ];
 
-  generateClient(sourceFile, lexicons, true);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should create CRUD methods
···
     },
   ];
 
-  generateClient(sourceFile, lexicons, true);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Main client constructor
-  assertStringIncludes(result, "constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient)");
+  assertStringIncludes(result, "constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient | AuthProvider)");
   assertStringIncludes(result, "super(baseUrl, sliceUri, oauthClient);");
 
   // Nested class constructors
···
   assertStringIncludes(result, "this.client = client;");
 });
 
-Deno.test("generateClient - includes network.slices specific methods when not excluded", () => {
+Deno.test("generateClient - creates client for network.slices lexicons", () => {
   const project = createTestProject();
   const sourceFile = project.createSourceFile("test.ts", "");
 
···
     },
   ];
 
-  generateClient(sourceFile, lexicons, false);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
-  // Should include network.slices specific methods
-  assertStringIncludes(result, "async stats(");
-  assertStringIncludes(result, "async getSparklines(");
-  assertStringIncludes(result, "async getSliceRecords<T = Record<string, unknown>>(");
-  assertStringIncludes(result, "async getActors(");
-  assertStringIncludes(result, "async startSync(");
-  assertStringIncludes(result, "async getJobStatus(");
-  assertStringIncludes(result, "async createOAuthClient(");
-  assertStringIncludes(result, "async syncUserCollections(");
+  // Should create proper client structure for network.slices
+  assertStringIncludes(result, "export class AtProtoClient extends SlicesClient");
+  assertStringIncludes(result, "class NetworkClient");
+  assertStringIncludes(result, "class SlicesNetworkClient");
+  assertStringIncludes(result, "readonly network: NetworkClient;");
+  assertStringIncludes(result, "readonly slices: SlicesNetworkClient;");
+
+  // Should include standard CRUD methods
+  assertStringIncludes(result, "async getRecords(");
+  assertStringIncludes(result, "async createRecord(");
 });
 
-Deno.test("generateClient - excludes network.slices methods when excluded", () => {
+Deno.test("generateClient - handles mixed lexicon types", () => {
   const project = createTestProject();
   const sourceFile = project.createSourceFile("test.ts", "");
 
   const lexicons: Lexicon[] = [
     {
+      id: "app.bsky.feed.post",
+      definitions: {
+        main: {
+          type: "record",
+          record: {
+            type: "record",
+            properties: { text: { type: "string" } },
+          },
+        },
+      },
+    },
+    {
       id: "network.slices.slice",
       definitions: {
         main: {
···
     },
   ];
 
-  generateClient(sourceFile, lexicons, true);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
-  // Should not include network.slices specific methods when excluded
-  assertEquals(result.includes("async codegen("), false);
-  assertEquals(result.includes("async getSliceRecords<T"), false);
-  assertEquals(result.includes("async createOAuthClient("), false);
+  // Should include both app.bsky and network.slices clients
+  assertStringIncludes(result, "class AppClient");
+  assertStringIncludes(result, "class NetworkClient");
+  assertStringIncludes(result, "readonly app: AppClient;");
+  assertStringIncludes(result, "readonly network: NetworkClient;");
 });
 
 Deno.test("generateClient - handles deep nesting correctly", () => {
···
     },
   ];
 
-  generateClient(sourceFile, lexicons, true);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should create proper nesting: app.bsky.feed and app.bsky.actor
···
     },
   ];
 
-  generateClient(sourceFile, lexicons, true);
+  generateClient(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should not create any client classes for non-record lexicons

packages/codegen/tests/integration_test.ts

···
 
   const result = await generateTypeScript(lexicons, {
     sliceUri: "at://did:example/com.example.slice/abc123",
-    excludeSlicesClient: false,
   });
 
   // Should include header comment with usage example
···
   assertStringIncludes(result, "async getRecords(");
   assertStringIncludes(result, "async createRecord(");
 
-  assertStringIncludes(result, "async getSliceRecords<T");
-
-  assertStringIncludes(result, "export interface BulkSyncParams");
+  // Should include standard client methods for all lexicons
 
   // Code should be formatted (no obvious formatting issues)
   assertEquals(result.includes("  ;"), false); // Double spaces before semicolons
   assertEquals(result.includes("\t\t\t"), false); // Triple tabs
 });
 
-Deno.test("generateTypeScript - excludes slices client correctly", async () => {
+Deno.test("generateTypeScript - generates client for standard lexicons", async () => {
   const lexicons: Lexicon[] = [
     {
       id: "app.bsky.feed.post",
···
 
   const result = await generateTypeScript(lexicons, {
     sliceUri: "at://test/slice",
-    excludeSlicesClient: true,
   });
 
-  // Should not include slice-specific imports
-  assertEquals(result.includes("SliceLevelRecordsParams"), false);
-  assertEquals(result.includes("GetActorsParams"), false);
-
-  assertEquals(result.includes("BulkSyncParams"), false);
-
-  assertEquals(result.includes("async getSliceRecords<T"), false);
-
-  // Should still include basic functionality
+  // Should include basic functionality
   assertStringIncludes(result, "export interface AppBskyFeedPost");
   assertStringIncludes(result, "export class AtProtoClient");
   assertStringIncludes(result, "async getRecords(");
+  assertStringIncludes(result, "text?: string;");
+
+  // Should include imports
+  assertStringIncludes(result, 'SlicesClient');
+  assertStringIncludes(result, 'OAuthClient');
 });
 
 Deno.test("generateTypeScript - handles empty lexicons", async () => {
   const result = await generateTypeScript([], {
     sliceUri: "at://test/slice",
-    excludeSlicesClient: false,
   });
 
   // Should include basic structure even with no lexicons
···
   assertStringIncludes(result, "Lexicons: 0");
   assertStringIncludes(result, 'SlicesClient');
 
-  // Should include network.slices interfaces
-  assertStringIncludes(result, "export interface BulkSyncParams");
+  // Should include imports even with no lexicons
+  assertStringIncludes(result, "@slices/client");
 
   // Should not create any client class (no records to work with)
   assertEquals(result.includes("export class AtProtoClient"), false);
···
 
   const result = await generateTypeScript(lexicons, {
     sliceUri: "at://did:example/slice/123",
-    excludeSlicesClient: false,
   });
 
   // Should create usage example with the first non-network.slices lexicon
   assertStringIncludes(result, "client.social.app.post.getRecords()");
   assertStringIncludes(result, "at://did:example/slice/123");
   assertStringIncludes(result, "social.app.post");
-  assertStringIncludes(result, "getSliceRecords<SocialAppPost>");
+  assertStringIncludes(result, "getRecords()");
 });

packages/codegen/tests/interfaces_test.ts

···
     },
   ];
 
-  generateInterfaces(sourceFile, lexicons, true);
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should create interface for the record
···
     },
   ];
 
-  generateInterfaces(sourceFile, lexicons, true);
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   assertStringIncludes(result, "export interface AppBskyEmbedDefsAspectRatio");
···
     },
   ];
 
-  generateInterfaces(sourceFile, lexicons, true);
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   assertStringIncludes(result, "export type AppBskyEmbedDefsView");
···
     },
   ];
 
-  generateInterfaces(sourceFile, lexicons, true);
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   assertStringIncludes(result, "export type ComExamplePostStatus");
···
     },
   ];
 
-  generateInterfaces(sourceFile, lexicons, true);
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should create namespace interface for multiple definitions
···
   assertStringIncludes(result, "readonly View: AppBskyEmbedDefsView;");
 });
 
-Deno.test("generateInterfaces - includes network.slices interfaces when not excluded", () => {
+Deno.test("generateInterfaces - generates from network.slices lexicons", () => {
   const project = createTestProject();
   const sourceFile = project.createSourceFile("test.ts", "");
 
-  generateInterfaces(sourceFile, [], false);
+  const lexicons = [
+    {
+      id: "network.slices.slice",
+      definitions: {
+        main: {
+          type: "record",
+          record: {
+            type: "record",
+            properties: {
+              name: { type: "string" },
+            },
+            required: ["name"],
+          },
+        },
+      },
+    },
+  ];
+
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
-  assertStringIncludes(result, "export interface BulkSyncParams");
-  assertStringIncludes(result, "export interface JobStatus");
-  assertStringIncludes(result, "export interface OAuthClientDetails");
+  assertStringIncludes(result, "export interface NetworkSlicesSlice");
+  assertStringIncludes(result, "name: string;");
 });
 
-Deno.test("generateInterfaces - excludes network.slices interfaces when excluded", () => {
+Deno.test("generateInterfaces - generates empty output for empty lexicons", () => {
   const project = createTestProject();
   const sourceFile = project.createSourceFile("test.ts", "");
 
-  generateInterfaces(sourceFile, [], true);
+  generateInterfaces(sourceFile, []);
   const result = sourceFile.getFullText();
 
-  assertEquals(result.includes("CodegenXrpcRequest"), false);
-  assertEquals(result.includes("BulkSyncParams"), false);
-  assertEquals(result.includes("JobStatus"), false);
+  // Should have minimal output for empty lexicons
+  assertEquals(result.trim(), "");
 });
 
 Deno.test("generateInterfaces - handles single definition lexicons", () => {
···
     },
   ];
 
-  generateInterfaces(sourceFile, lexicons, true);
+  generateInterfaces(sourceFile, lexicons);
   const result = sourceFile.getFullText();
 
   // Should use clean name for single definition

packages/codegen/tests/utils_test.ts

···
   ];
 
   const usageExample = "/** Example usage */";
-  const result = generateHeaderComment(lexicons, usageExample, false);
+  const result = generateHeaderComment(lexicons, usageExample);
 
   assertEquals(typeof result, "string");
   assertEquals(result.includes("Generated TypeScript client"), true);
···
   assertEquals(result.includes("@slices/oauth"), true);
 });
 
-Deno.test("generateHeaderComment - excludes slices client imports", () => {
+Deno.test("generateHeaderComment - generates consistent imports", () => {
   const lexicons: Lexicon[] = [];
   const usageExample = "/** Example */";
-  const result = generateHeaderComment(lexicons, usageExample, true);
+  const result = generateHeaderComment(lexicons, usageExample);
 
-  assertEquals(result.includes("SliceLevelRecordsParams"), false);
-  assertEquals(result.includes("GetActorsParams"), false);
+  assertEquals(result.includes("SlicesClient"), true);
+  assertEquals(result.includes("@slices/client"), true);
+  assertEquals(result.includes("@slices/oauth"), true);
 });