add clearSliceRecords procedure to empty the index for a slice, add cascade delete funciton to clean up slice records on delete and on lexicon delete, add button to slice settings page

api/src/api/xrpc_dynamic.rs

···
 
     // Also delete from local database (from all slices)
     let uri = format!("at://{}/{}/{}", repo, collection, rkey);
+
+    // Handle cascade deletion before deleting the record
+    if let Err(e) = state.database.handle_cascade_deletion(&uri, &collection).await {
+        tracing::warn!("Cascade deletion failed for {}: {}", uri, e);
+    }
+
     let _ = state.database.delete_record_by_uri(&uri, None).await;
 
     Ok(Json(serde_json::json!({})))

api/src/database/actors.rs

···
         .await?;
         Ok(result.rows_affected())
     }
+
+    /// Deletes all actors for a specific slice.
+    ///
+    /// This is a destructive operation that removes all tracked actors
+    /// from the specified slice. Actors will be recreated when records
+    /// are re-indexed during sync.
+    ///
+    /// # Arguments
+    /// * `slice_uri` - AT-URI of the slice to clear
+    ///
+    /// # Returns
+    /// Number of actors deleted
+    pub async fn delete_all_actors_for_slice(
+        &self,
+        slice_uri: &str,
+    ) -> Result<u64, DatabaseError> {
+        let result = sqlx::query!(
+            r#"
+            DELETE FROM actor
+            WHERE slice_uri = $1
+            "#,
+            slice_uri
+        )
+        .execute(&self.pool)
+        .await?;
+        Ok(result.rows_affected())
+    }
 }
 
 /// Builds WHERE conditions specifically for actor queries.

api/src/database/records.rs

···
         Ok(result.rows_affected())
     }
 
+    /// Deletes all records for a specific slice.
+    ///
+    /// This is a destructive operation that removes all indexed records
+    /// from the specified slice. Records can be recovered by re-syncing.
+    ///
+    /// # Arguments
+    /// * `slice_uri` - AT-URI of the slice to clear
+    ///
+    /// # Returns
+    /// Number of records deleted
+    pub async fn delete_all_records_for_slice(
+        &self,
+        slice_uri: &str,
+    ) -> Result<u64, DatabaseError> {
+        let result = sqlx::query("DELETE FROM record WHERE slice_uri = $1")
+            .bind(slice_uri)
+            .execute(&self.pool)
+            .await?;
+        Ok(result.rows_affected())
+    }
+
+    /// Deletes all records of a specific collection from a slice.
+    ///
+    /// Used when a lexicon is deleted to clean up all records of that type.
+    ///
+    /// # Arguments
+    /// * `slice_uri` - AT-URI of the slice
+    /// * `collection` - Collection name (NSID) to delete
+    ///
+    /// # Returns
+    /// Number of records deleted
+    pub async fn delete_records_by_collection(
+        &self,
+        slice_uri: &str,
+        collection: &str,
+    ) -> Result<u64, DatabaseError> {
+        let result = sqlx::query("DELETE FROM record WHERE slice_uri = $1 AND collection = $2")
+            .bind(slice_uri)
+            .bind(collection)
+            .execute(&self.pool)
+            .await?;
+        Ok(result.rows_affected())
+    }
+
+    /// Handles cascade deletion based on record type.
+    ///
+    /// When certain records are deleted, related data should be cleaned up:
+    /// - Lexicon deletion: removes all records of that collection type
+    /// - Slice deletion: removes all records and actors for that slice
+    ///
+    /// # Arguments
+    /// * `uri` - AT-URI of the deleted record
+    /// * `collection` - Collection name (e.g., "network.slices.lexicon")
+    pub async fn handle_cascade_deletion(&self, uri: &str, collection: &str) -> Result<(), DatabaseError> {
+        match collection {
+            "network.slices.lexicon" => {
+                // Get the lexicon record to extract collection name and slice URI
+                if let Ok(Some(lexicon_record)) = self.get_record(uri).await
+                    && let (Some(nsid), Some(slice_uri_from_record)) = (
+                        lexicon_record.value.get("nsid").and_then(|v| v.as_str()),
+                        lexicon_record.value.get("slice").and_then(|v| v.as_str())
+                    )
+                {
+                    // Delete all records of this collection type from the slice
+                    let deleted = self.delete_records_by_collection(slice_uri_from_record, nsid).await?;
+                    tracing::info!(
+                        "Cascade delete: removed {} records of collection {} from slice {}",
+                        deleted, nsid, slice_uri_from_record
+                    );
+                }
+            }
+            "network.slices.slice" => {
+                // The URI itself is the slice URI
+                let slice_uri = uri;
+
+                // Delete all records for this slice
+                let records_deleted = self.delete_all_records_for_slice(slice_uri).await?;
+                tracing::info!(
+                    "Cascade delete: removed {} records from slice {}",
+                    records_deleted, slice_uri
+                );
+
+                // Delete all actors for this slice
+                let actors_deleted = super::client::Database::delete_all_actors_for_slice(self, slice_uri).await?;
+                tracing::info!(
+                    "Cascade delete: removed {} actors from slice {}",
+                    actors_deleted, slice_uri
+                );
+            }
+            _ => {
+                // No cascade deletion needed for other collections
+            }
+        }
+        Ok(())
+    }
+
     /// Inserts or updates a record atomically.
     ///
     /// # Returns

api/src/jetstream.rs

···
             return Ok(());
         }
 
+        // Handle cascade deletion before deleting the record
+        if let Err(e) = self.database.handle_cascade_deletion(&uri, &commit.collection).await {
+            warn!("Cascade deletion failed for {}: {}", uri, e);
+        }
+
         // Delete the record and log only for relevant slices
         match self.database.delete_record_by_uri(&uri, None).await {
             Ok(rows_affected) => {

api/src/main.rs

···
             post(xrpc::network::slices::slice::sync_user_collections::handler),
         )
         .route(
+            "/xrpc/network.slices.slice.clearSliceRecords",
+            post(xrpc::network::slices::slice::clear_slice_records::handler),
+        )
+        .route(
             "/xrpc/network.slices.slice.getJobStatus",
             get(xrpc::network::slices::slice::get_job_status::handler),
         )

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

···
+use crate::{auth, errors::AppError, AppState};
+use axum::{extract::State, http::HeaderMap, response::Json};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Params {
+    pub slice: 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)?;
+    let user_info = auth::verify_oauth_token_cached(
+        &token,
+        &state.config.auth_base_url,
+        Some(state.auth_cache.clone()),
+    )
+    .await?;
+
+    let user_did = user_info.sub;
+    let slice_uri = params.slice;
+
+    if !slice_uri.starts_with(&format!("at://{}/", user_did)) {
+        return Err(AppError::Forbidden(
+            "You do not have permission to clear this slice".to_string(),
+        ));
+    }
+
+    let records_deleted = state
+        .database
+        .delete_all_records_for_slice(&slice_uri)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to delete records: {}", e)))?;
+
+    let actors_deleted = state
+        .database
+        .delete_all_actors_for_slice(&slice_uri)
+        .await
+        .map_err(|e| AppError::Internal(format!("Failed to delete actors: {}", e)))?;
+
+    Ok(Json(Output {
+        message: format!(
+            "Slice index cleared successfully. Deleted {} records and {} actors.",
+            records_deleted, actors_deleted
+        ),
+    }))
+}

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

···
+pub mod clear_slice_records;
 pub mod create_oauth_client;
 pub mod delete_oauth_client;
 pub mod get_actors;

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-28 00:41:14 UTC
-// Lexicons: 40
+// Generated at: 2025-09-28 17:28:31 UTC
+// Lexicons: 41
 
 /**
  * @example Usage
···
   sliceUri: string;
   /** When this actor was indexed */
   indexedAt: string;
+}
+
+export interface NetworkSlicesSliceClearSliceRecordsInput {
+  slice: string;
+}
+
+export interface NetworkSlicesSliceClearSliceRecordsOutput {
+  message: string;
 }
 
 export interface NetworkSlicesSliceDeleteOAuthClientInput {
···
       "POST",
       input,
     );
+  }
+
+  async clearSliceRecords(
+    input: NetworkSlicesSliceClearSliceRecordsInput,
+  ): Promise<NetworkSlicesSliceClearSliceRecordsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceClearSliceRecordsOutput
+    >("network.slices.slice.clearSliceRecords", "POST", input);
   }
 
   async deleteOAuthClient(

frontend/src/features/slices/lexicon/templates/fragments/LexiconsList.tsx

···
               hx-target="#lexicon-list"
               hx-swap="outerHTML"
               hx-include="input[name='lexicon_rkey']:checked"
-              hx-confirm="Are you sure you want to delete the selected lexicons?"
+              hx-confirm="Are you sure you want to delete the selected lexicons? This will also delete all records of those collection types from the index."
             >
               <span className="flex items-center">Delete Selected</span>
             </Button>

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

···
 
 async function handleSliceSettingsPage(
   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;
 
   const url = new URL(req.url);
   const updated = url.searchParams.get("updated");
+  const cleared = url.searchParams.get("cleared");
   const error = url.searchParams.get("error");
 
   return renderHTML(
···
       slice={context.sliceContext!.slice!}
       sliceId={sliceParams.sliceId}
       updated={updated === "true"}
+      cleared={cleared === "true"}
       error={error}
       currentUser={authContext.currentUser}
       hasSliceAccess={context.sliceContext?.hasAccess}
-    />,
+    />
   );
 }
 
 async function handleUpdateSliceSettings(
   req: Request,
-  params?: URLPatternResult,
+  params?: URLPatternResult
 ): Promise<Response> {
   const context = await withAuth(req);
   const sliceId = params?.pathname.groups.id;
···
     });
 
     return hxRedirect(
-      `/profile/${context.currentUser.handle}/slice/${sliceId}/settings?updated=true`,
+      `/profile/${context.currentUser.handle}/slice/${sliceId}/settings?updated=true`
     );
   } catch (_error) {
     return hxRedirect(
-      `/profile/${context.currentUser.handle}/slice/${sliceId}/settings?error=update_failed`,
+      `/profile/${context.currentUser.handle}/slice/${sliceId}/settings?error=update_failed`
+    );
+  }
+}
+
+async function handleClearSliceRecords(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
+  const context = await withAuth(req);
+  const sliceId = params?.pathname.groups.id;
+
+  if (!sliceId) {
+    return new Response("Slice ID is required", { status: 400 });
+  }
+
+  if (!context.currentUser.isAuthenticated) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  try {
+    const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
+    const sessionClient = createSessionClient(context.currentUser.sessionId!);
+
+    await sessionClient.network.slices.slice.clearSliceRecords({
+      slice: sliceUri,
+    });
+
+    return hxRedirect(
+      `/profile/${context.currentUser.handle}/slice/${sliceId}/settings?cleared=true`
+    );
+  } catch (error) {
+    console.log("Error clearing slice records:", error);
+    return hxRedirect(
+      `/profile/${context.currentUser.handle}/slice/${sliceId}/settings?error=clear_failed`
     );
   }
 }
 
 async function handleDeleteSlice(
   req: Request,
-  params?: URLPatternResult,
+  params?: URLPatternResult
 ): Promise<Response> {
   const context = await withAuth(req);
   const sliceId = params?.pathname.groups.id;
···
   }
 
   try {
-    // Create user-scoped client for delete operation
+    const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
     const sessionClient = createSessionClient(context.currentUser.sessionId!);
 
-    // Delete the slice record from AT Protocol
+    // 1. Delete all OAuth clients for this slice
+    try {
+      const oauthClients =
+        await sessionClient.network.slices.slice.getOAuthClients({
+          slice: sliceUri,
+        });
+
+      for (const client of oauthClients.clients) {
+        await sessionClient.network.slices.slice.deleteOAuthClient({
+          clientId: client.clientId,
+        });
+      }
+    } catch (_error) {
+      // Continue even if OAuth cleanup fails
+    }
+
+    // 2. Delete all lexicons for this slice
+    try {
+      const lexicons = await sessionClient.network.slices.lexicon.getRecords({
+        limit: 100,
+      });
+
+      for (const lexicon of lexicons.records) {
+        const rkey = lexicon.uri.split("/").pop();
+        if (rkey) {
+          await sessionClient.network.slices.lexicon.deleteRecord(rkey);
+        }
+      }
+    } catch (_error) {
+      // Continue even if lexicon cleanup fails
+    }
+
+    // 3. Delete the slice record from AT Protocol (this will trigger backend cleanup)
     await sessionClient.network.slices.slice.deleteRecord(sliceId);
 
     return hxRedirect(`/profile/${context.currentUser.handle}`);
···
     method: "PUT",
     pattern: new URLPattern({ pathname: "/api/slices/:id/settings" }),
     handler: handleUpdateSliceSettings,
+  },
+  {
+    method: "POST",
+    pattern: new URLPattern({ pathname: "/api/slices/:id/clear-records" }),
+    handler: handleClearSliceRecords,
   },
   {
     method: "DELETE",

frontend/src/features/slices/settings/templates/SliceSettings.tsx

···
   slice: NetworkSlicesSliceDefsSliceView;
   sliceId: string;
   updated?: boolean;
+  cleared?: boolean;
   error?: string | null;
   currentUser?: AuthenticatedUser;
   hasSliceAccess?: boolean;
···
   slice,
   sliceId,
   updated = false,
+  cleared = false,
   error = null,
   currentUser,
   hasSliceAccess,
···
         />
       )}
 
+      {/* Cleared Message */}
+      {cleared && (
+        <FlashMessage
+          type="success"
+          message="All records and actors cleared successfully!"
+        />
+      )}
+
       {/* Error Message */}
       {error && (
         <FlashMessage
···
           message={
             error === "update_failed"
               ? "Failed to update slice settings. Please try again."
+              : error === "clear_failed"
+              ? "Failed to clear records. Please try again."
               : "An error occurred."
           }
         />
···
           >
             Danger Zone
           </Text>
-          <Text as="p" variant="secondary" className="mb-4">
-            Permanently delete this slice and all associated data. This action
-            cannot be undone.
-          </Text>
-          <Button
-            type="button"
-            hx-delete={`/api/slices/${sliceId}`}
-            hx-confirm="Are you sure you want to delete this slice? This action cannot be undone."
-            hx-target="body"
-            hx-push-url="/"
-            variant="danger"
-            size="lg"
-          >
-            Delete Slice
-          </Button>
+
+          {/* Clear Records Section */}
+          <div className="mb-6 pb-6 border-b border-gray-200 dark:border-gray-700">
+            <Text as="p" variant="secondary" className="mb-4">
+              Clear all indexed records and actors from this slice. Data can be
+              re-indexed through sync.
+            </Text>
+            <Button
+              type="button"
+              hx-post={`/api/slices/${sliceId}/clear-records`}
+              hx-confirm="Are you sure you want to clear all records and actors from this slice? This will delete all indexed data."
+              hx-target="#clear-records-result"
+              hx-swap="innerHTML"
+              variant="danger"
+              size="lg"
+            >
+              Clear All Records
+            </Button>
+            <div id="clear-records-result" className="mt-4"></div>
+          </div>
+
+          {/* Delete Slice Section */}
+          <div>
+            <Text as="p" variant="secondary" className="mb-4">
+              Permanently delete this slice and all associated data. This action
+              cannot be undone.
+            </Text>
+            <Button
+              type="button"
+              hx-delete={`/api/slices/${sliceId}`}
+              hx-confirm="Are you sure you want to delete this slice? This action cannot be undone."
+              hx-target="body"
+              hx-push-url="/"
+              variant="danger"
+              size="lg"
+            >
+              Delete Slice
+            </Button>
+          </div>
         </Card>
       </div>
     </SlicePage>

lexicons/network/slices/slice/clearSliceRecords.json

···
+{
+  "lexicon": 1,
+  "id": "network.slices.slice.clearSliceRecords",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Clear all indexed records and actors from a slice. Data can be re-indexed through sync. Requires authentication.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["slice"],
+          "properties": {
+            "slice": {
+              "type": "string",
+              "description": "AT-URI of the slice to clear"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["message"],
+          "properties": {
+            "message": {
+              "type": "string",
+              "description": "Success message"
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/cli/src/generated_client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-28 00:41:51 UTC
-// Lexicons: 40
+// Generated at: 2025-09-28 17:28:24 UTC
+// Lexicons: 41
 
 /**
  * @example Usage
···
   sliceUri: string;
   /** When this actor was indexed */
   indexedAt: string;
+}
+
+export interface NetworkSlicesSliceClearSliceRecordsInput {
+  slice: string;
+}
+
+export interface NetworkSlicesSliceClearSliceRecordsOutput {
+  message: string;
 }
 
 export interface NetworkSlicesSliceDeleteOAuthClientInput {
···
       "POST",
       input,
     );
+  }
+
+  async clearSliceRecords(
+    input: NetworkSlicesSliceClearSliceRecordsInput,
+  ): Promise<NetworkSlicesSliceClearSliceRecordsOutput> {
+    return await this.client.makeRequest<
+      NetworkSlicesSliceClearSliceRecordsOutput
+    >("network.slices.slice.clearSliceRecords", "POST", input);
   }
 
   async deleteOAuthClient(