clean up /api, use social.slices

api/migrations/002_lexicons.sql

···
--- Add lexicons table for storing AT Protocol lexicon schemas
-CREATE TABLE IF NOT EXISTS "lexicons" (
-    "nsid" TEXT PRIMARY KEY NOT NULL,
-    "definitions" JSONB NOT NULL,
-    "created_at" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
-    "updated_at" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_lexicons_nsid ON "lexicons"("nsid");
-CREATE INDEX IF NOT EXISTS idx_lexicons_definitions ON "lexicons" USING gin("definitions");

api/scripts/generated_client.ts

···
-null

api/scripts/test_codegen.sh

···
 
 # Test with multiple lexicons
 echo "📝 Generating TypeScript client with multiple lexicons..."
-curl -s -X POST http://localhost:3000/xrpc/social.slices.codegen.generate \
+curl -s -X POST http://localhost:3000/xrpc/social.slices.slice.codegen \
   -H "Content-Type: application/json" \
   -d '{
-    "target": "typescript-deno",
-    "client_type": "records",
-    "lexicons": ["social.grain.gallery", "social.grain.comment"]
+    "target": "typescript",
+    "lexicons": ["social.slices.slice", "social.slices.lexicon"]
   }' | jq -r '.generated_code' > generated_client.ts
 
 if [ $? -eq 0 ] && [ -f generated_client.ts ]; then
···
     echo "📊 Generated code stats:"
     echo "   Lines: $(wc -l < generated_client.ts)"
     echo "   Size: $(du -h generated_client.ts | cut -f1)"
-    
+
     echo ""
     echo "🔍 Preview of generated interfaces:"
     grep -A 5 "export interface.*Record {" generated_client.ts || echo "No record interfaces found"
-    
+
     echo ""
     echo "🎯 Preview of auto-typing examples:"
     grep -A 10 "// Usage examples:" generated_client.ts || echo "No usage examples found"
···
 fi
 
 echo ""
-echo "🎉 Test complete! Check generated_client.ts to see the auto-typing functionality."
+echo "🎉 Test complete! Check generated_client.ts to see the auto-typing functionality."

api/scripts/test_sync.sh

···
+#!/bin/bash
+
+echo "🔄 Testing Sync Endpoint..."
+
+echo "🎯 Syncing specific collections with specific repos"
+curl -s -X POST http://localhost:3000/xrpc/social.slices.slice.sync \
+  -H "Content-Type: application/json" \
+  -d '{
+    "collections": [
+      "social.slice.slice",
+      "social.slice.lexicon"
+    ],
+    "repos": [
+      "did:plc:bcgltzqazw5tb6k2g3ttenbj"
+    ]
+  }' | jq '.'
+
+echo ""
+echo "✅ Sync test complete!"

api/src/codegen/typescript.rs

···
-use crate::models::Lexicon;
-
 pub struct TypeScriptGenerator;
 
 impl TypeScriptGenerator {
···
         Self
     }
 
-    pub fn generate_client(&self, lexicons: &[Lexicon]) -> Result<String, String> {
-        // Serialize lexicons to JSON for the Deno script
-        let lexicons_json = serde_json::to_string(lexicons)
-            .map_err(|e| format!("Failed to serialize lexicons: {}", e))?;
-        
-        // Call the Deno script to generate TypeScript with proper comments
-        let output = std::process::Command::new("deno")
-            .arg("run")
-            .arg("--allow-all")
-            .arg("scripts/generate-typescript.ts")
-            .arg(&lexicons_json)
-            .output()
-            .map_err(|e| format!("Failed to execute deno script: {}", e))?;
-        
-        if !output.status.success() {
-            let stderr = String::from_utf8_lossy(&output.stderr);
-            return Err(format!("Deno script failed: {}", stderr));
-        }
-        
-        let generated_code = String::from_utf8(output.stdout)
-            .map_err(|e| format!("Failed to decode output: {}", e))?;
-            
-        Ok(generated_code)
+    pub fn generate_client(&self, _lexicons_json: &str) -> Result<String, String> {
+        // TODO: Implement TypeScript generation - functionality moved to /frontend
+        Ok("// TypeScript generation placeholder - functionality moved to /frontend\n".to_string())
     }
 }

api/src/database.rs

···
 use sqlx::PgPool;
 
 use crate::errors::DatabaseError;
-use crate::models::{Actor, IndexedRecord, Lexicon, ListRecordsParams, Record};
+use crate::models::{Actor, IndexedRecord, Record};
 
 #[derive(Clone)]
 pub struct Database {
···
         Ok(indexed_record)
     }
 
-    pub async fn list_records(&self, params: ListRecordsParams) -> Result<Vec<IndexedRecord>, DatabaseError> {
-        let limit = params.limit.unwrap_or(25).min(100);
+    pub async fn list_records(&self, collection: &str, author: Option<&str>, limit: Option<i32>) -> Result<Vec<IndexedRecord>, DatabaseError> {
+        let limit = limit.unwrap_or(25).min(100);
 
         let records = sqlx::query_as::<_, Record>(
             r#"SELECT "uri", "cid", "did", "collection", "json", "indexedAt"
···
                ORDER BY "indexedAt" DESC
                LIMIT $3"#,
         )
-        .bind(&params.collection)
-        .bind(&params.author)
+        .bind(collection)
+        .bind(author)
         .bind(limit)
         .fetch_all(&self.pool)
         .await?;
···
         Ok(indexed_records)
     }
 
-    pub async fn get_available_collections(&self) -> Result<Vec<(String, i64)>, DatabaseError> {
-        let collections = sqlx::query!(
-            r#"SELECT "collection", COUNT(*) as count
+    pub async fn get_lexicons_by_slice(&self, slice_uri: &str) -> Result<Vec<serde_json::Value>, DatabaseError> {
+        let records = sqlx::query_as::<_, Record>(
+            r#"SELECT "uri", "cid", "did", "collection", "json", "indexedAt"
                FROM "record"
-               GROUP BY "collection"
-               ORDER BY count DESC, "collection" ASC"#
+               WHERE "collection" = 'social.slices.lexicon'
+               AND "json"->>'slice' = $1
+               ORDER BY "indexedAt" DESC"#,
         )
+        .bind(slice_uri)
         .fetch_all(&self.pool)
         .await?;
 
-        Ok(collections
+        let lexicon_definitions: Vec<serde_json::Value> = records
             .into_iter()
-            .map(|row| (row.collection, row.count.unwrap_or(0)))
-            .collect())
+            .filter_map(|record| record.json.get("definition").cloned())
+            .collect();
+
+        Ok(lexicon_definitions)
     }
+
+
 
     pub async fn get_total_record_count(&self) -> Result<i64, DatabaseError> {
         let count = sqlx::query!("SELECT COUNT(*) as count FROM record")
···
         Ok(count.count.unwrap_or(0))
     }
 
-    pub async fn insert_lexicon(&self, lexicon: &Lexicon) -> Result<(), DatabaseError> {
-        sqlx::query!(
-            r#"INSERT INTO "lexicons" ("nsid", "definitions", "created_at", "updated_at")
-               VALUES ($1, $2, $3, $4)
-               ON CONFLICT ("nsid")
-               DO UPDATE SET
-                   "definitions" = EXCLUDED."definitions",
-                   "updated_at" = EXCLUDED."updated_at""#,
-            lexicon.nsid,
-            lexicon.definitions,
-            lexicon.created_at,
-            lexicon.updated_at
-        )
-        .execute(&self.pool)
-        .await?;
-
-        Ok(())
-    }
-
-    pub async fn get_lexicon(&self, nsid: &str) -> Result<Option<Lexicon>, DatabaseError> {
-        let lexicon = sqlx::query_as::<_, Lexicon>(
-            r#"SELECT "nsid", "definitions", "created_at", "updated_at"
-               FROM "lexicons"
-               WHERE "nsid" = $1"#,
-        )
-        .bind(nsid)
-        .fetch_optional(&self.pool)
-        .await?;
-
-        Ok(lexicon)
-    }
-
-    pub async fn get_all_lexicons(&self) -> Result<Vec<Lexicon>, DatabaseError> {
-        let lexicons = sqlx::query_as::<_, Lexicon>(
-            r#"SELECT "nsid", "definitions", "created_at", "updated_at"
-               FROM "lexicons"
-               ORDER BY "nsid""#,
-        )
-        .fetch_all(&self.pool)
-        .await?;
-
-        Ok(lexicons)
-    }
 
     pub async fn update_record(&self, record: &Record) -> Result<(), DatabaseError> {
         let result = sqlx::query!(

api/src/errors.rs

···
 use thiserror::Error;
 
-#[derive(Error, Debug)]
-pub enum LexiconError {
-    #[error("error-slice-lexicon-1 Failed to parse multipart boundary: {0}")]
-    MultipartBoundary(String),
-
-    #[error("error-slice-lexicon-2 Failed to read request body: {0}")]
-    RequestBody(String),
-
-    #[error("error-slice-lexicon-3 Failed to parse zip archive: {0}")]
-    ZipArchive(String),
-
-    #[error("error-slice-lexicon-4 Failed to read file from archive: {0}")]
-    FileRead(String),
-
-    #[error("error-slice-lexicon-5 Failed to parse JSON lexicon: {0}")]
-    JsonParse(String),
-}
 
 #[derive(Error, Debug)]
 pub enum DatabaseError {
     #[error("error-slice-database-1 SQL query failed: {0}")]
     SqlQuery(#[from] sqlx::Error),
 
-    #[error("error-slice-database-2 Transaction failed: {0}")]
-    Transaction(String),
-
-    #[error("error-slice-database-3 Record not found: {uri}")]
+    #[error("error-slice-database-2 Record not found: {uri}")]
     RecordNotFound { uri: String },
 }
 
···
 
     #[error("error-slice-app-3 Server bind failed: {0}")]
     ServerBind(#[from] std::io::Error),
-
-    #[error("error-slice-app-4 Environment variable error: {0}")]
-    Environment(String),
 }
 

api/src/handler_codegen.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::{Html, IntoResponse},
-};
-use axum_extra::extract::Form;
-use minijinja::{context, Environment};
-use serde::Deserialize;
-use crate::AppState;
-use crate::codegen::TypeScriptGenerator;
-
-#[derive(Deserialize)]
-pub struct CodegenForm {
-    target: String,
-    client_type: String,
-    #[serde(default)]
-    lexicons: Vec<String>,
-}
-
-
-pub async fn generate_client(
-    State(state): State<AppState>,
-    Form(form): Form<CodegenForm>,
-) -> Result<impl IntoResponse, StatusCode> {
-    let selected_lexicons = form.lexicons;
-
-    if selected_lexicons.is_empty() {
-        return Ok(Html(r#"
-            <div class="alert alert-error">
-                <h4>❌ No lexicons selected</h4>
-                <p>Please select at least one lexicon to generate client code.</p>
-            </div>
-        "#.to_string()));
-    }
-
-    // Fetch the selected lexicons from database
-    let mut lexicons = Vec::new();
-    for nsid in &selected_lexicons {
-        if let Ok(Some(lexicon)) = state.database.get_lexicon(nsid).await {
-            lexicons.push(lexicon);
-        }
-    }
-
-    let generated_code = match form.target.as_str() {
-        "typescript-deno" => match form.client_type.as_str() {
-            "records" => {
-                let generator = TypeScriptGenerator::new();
-                match generator.generate_client(&lexicons) {
-                    Ok(code) => code,
-                    Err(e) => return Ok(Html(format!(r#"
-                        <div class="alert alert-error">
-                            <h4>❌ TypeScript generation failed</h4>
-                            <p>Error: {}</p>
-                        </div>
-                    "#, e))),
-                }
-            },
-            _ => return Ok(Html(r#"
-                <div class="alert alert-error">
-                    <h4>❌ Unsupported client type</h4>
-                    <p>Only "records" client type is currently supported.</p>
-                </div>
-            "#.to_string())),
-        },
-        _ => return Ok(Html(r#"
-            <div class="alert alert-error">
-                <h4>❌ Unsupported target</h4>
-                <p>Only "typescript-deno" is currently supported.</p>
-            </div>
-        "#.to_string())),
-    };
-
-    let mut env = Environment::new();
-    env.add_template("codegen_result.html", r#"
-        <div class="alert alert-success">
-            <h4>✅ Client code generated successfully!</h4>
-            <p><strong>Target:</strong> {{ target }}</p>
-            <p><strong>Client Type:</strong> {{ client_type }}</p>
-            <p><strong>Lexicons:</strong> {{ lexicons_count }}</p>
-
-            <div class="mt-4">
-                <div class="flex justify-between items-center mb-2">
-                    <h5 class="font-medium text-gray-800">Generated Code</h5>
-                    <button onclick="navigator.clipboard.writeText(document.getElementById('generated-code').textContent);"
-                            class="bg-blue-500 text-white px-3 py-1 rounded text-sm">
-                        Copy to Clipboard
-                    </button>
-                </div>
-                <pre id="generated-code" class="bg-gray-100 p-4 rounded text-xs overflow-x-auto max-h-96 overflow-y-auto">{{ generated_code }}</pre>
-            </div>
-        </div>
-    "#).unwrap();
-
-    let tmpl = env.get_template("codegen_result.html").unwrap();
-    let rendered = tmpl.render(context! {
-        target => form.target,
-        client_type => form.client_type,
-        lexicons_count => lexicons.len(),
-        generated_code => generated_code
-    }).unwrap();
-
-    Ok(Html(rendered))
-}

api/src/handler_dynamic_xrpc.rs api/src/handler_xrpc_dynamic.rs

···
 use atproto_identity::key::KeyData;
 use atproto_oauth::jwk::WrappedJsonWebKey;
 
-use crate::models::{ListRecordsParams, ListRecordsOutput, Record};
+use crate::models::{ListRecordsOutput, Record};
 use crate::AppState;
 
 #[derive(Deserialize)]
···
     pub uri: String,
 }
 
-#[derive(Deserialize)]
-pub struct CreateRecordParams {
-    pub repo: String,
-    pub collection: String,
-    pub rkey: Option<String>,
-    pub record: serde_json::Value,
-}
-
-#[derive(Deserialize)]
-pub struct UpdateRecordParams {
-    pub repo: String,
-    pub collection: String,
-    pub rkey: String,
-    pub record: serde_json::Value,
-}
-
-#[derive(Deserialize)]
-pub struct DeleteRecordParams {
-    pub repo: String,
-    pub collection: String,
-    pub rkey: String,
-}
-
-#[derive(Serialize)]
-pub struct CreateRecordOutput {
-    pub uri: String,
-    pub cid: String,
-}
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct UserInfoResponse {
···
     let dynamic_params: DynamicListParams = serde_json::from_value(params)
         .map_err(|_| StatusCode::BAD_REQUEST)?;
 
-    let list_params = ListRecordsParams {
-        collection,
-        author: dynamic_params.author,
-        limit: dynamic_params.limit,
-        cursor: dynamic_params.cursor,
-    };
-
-    match state.database.list_records(list_params).await {
+    match state.database.list_records(&collection, dynamic_params.author.as_deref(), dynamic_params.limit).await {
         Ok(records) => {
             let output = ListRecordsOutput {
                 records,

api/src/handler_lexicon.rs

···
-use axum::{
-    extract::State,
-    http::StatusCode,
-    response::{Html, IntoResponse},
-};
-use minijinja::{context, Environment};
-
-use crate::AppState;
-
-pub async fn lexicon_page(
-    State(state): State<AppState>,
-) -> Result<impl IntoResponse, StatusCode> {
-    let lexicons = state.database.get_all_lexicons().await.unwrap_or_default();
-
-    // Transform lexicons to include pretty-printed JSON
-    let lexicons_with_pretty_json: Vec<serde_json::Value> = lexicons.into_iter().map(|lexicon| {
-        let pretty_definitions = serde_json::to_string_pretty(&lexicon.definitions).unwrap_or_else(|_| "{}".to_string());
-        serde_json::json!({
-            "nsid": lexicon.nsid,
-            "definitions": lexicon.definitions,
-            "pretty_definitions": pretty_definitions,
-            "created_at": lexicon.created_at,
-            "updated_at": lexicon.updated_at
-        })
-    }).collect();
-
-    let mut env = Environment::new();
-    env.add_template("base.html", include_str!("../templates/base.html")).unwrap();
-    env.add_template("lexicon.html", include_str!("../templates/lexicon.html")).unwrap();
-
-    let tmpl = env.get_template("lexicon.html").unwrap();
-    let rendered = tmpl.render(context! {
-        title => "Lexicon Definitions",
-        lexicons => lexicons_with_pretty_json
-    }).unwrap();
-
-    Ok(Html(rendered))
-}

api/src/handler_sync.rs

···
+use axum::{
+    extract::State,
+    http::StatusCode,
+    response::Json,
+};
+use crate::models::{BulkSyncOutput, BulkSyncParams};
+use crate::AppState;
+
+pub async fn sync(
+    State(state): State<AppState>,
+    axum::extract::Json(params): axum::extract::Json<BulkSyncParams>,
+) -> Result<Json<BulkSyncOutput>, StatusCode> {
+    match state
+        .sync_service
+        .backfill_collections(&params.collections, params.repos.as_deref())
+        .await
+    {
+        Ok(_) => {
+            let total_records = state.database.get_total_record_count().await.unwrap_or(0);
+            Ok(Json(BulkSyncOutput {
+                success: true,
+                total_records,
+                collections_synced: params.collections,
+                repos_processed: params.repos.map(|r| r.len() as i64).unwrap_or(0),
+                message: "Sync completed successfully".to_string(),
+            }))
+        }
+        Err(e) => Ok(Json(BulkSyncOutput {
+            success: false,
+            total_records: 0,
+            collections_synced: vec![],
+            repos_processed: 0,
+            message: format!("Sync failed: {}", e),
+        })),
+    }
+}

api/src/handler_upload_lexicon.rs

···
-use axum::{
-    extract::{Request, State},
-    http::StatusCode,
-    response::{Html, IntoResponse},
-};
-use axum::body::to_bytes;
-use multer::Multipart;
-use futures_util::stream::once;
-use crate::errors::LexiconError;
-use crate::models::Lexicon;
-use crate::AppState;
-use minijinja::{context, Environment};
-use serde::Deserialize;
-use std::collections::HashSet;
-use std::io::Read;
-use tracing::{error, warn};
-use zip::ZipArchive;
-use chrono::Utc;
-
-#[derive(Deserialize)]
-struct LexiconFile {
-    id: String,
-    defs: serde_json::Map<String, serde_json::Value>,
-}
-
-pub async fn upload_lexicons(
-    State(state): State<AppState>,
-    request: Request,
-) -> Result<impl IntoResponse, StatusCode> {
-
-    let boundary = request
-        .headers()
-        .get("content-type")
-        .and_then(|ct| ct.to_str().ok())
-        .and_then(|ct| multer::parse_boundary(ct).ok())
-        .ok_or_else(|| {
-            let err = LexiconError::MultipartBoundary("Missing or invalid content-type header".to_string());
-            error!("{}", err);
-            StatusCode::BAD_REQUEST
-        })?;
-
-    let body = request.into_body();
-    let body_bytes = to_bytes(body, usize::MAX).await.map_err(|e| {
-        let err = LexiconError::RequestBody(e.to_string());
-        error!("{}", err);
-        StatusCode::BAD_REQUEST
-    })?;
-
-
-    let body_stream = once(async move { Ok::<_, multer::Error>(body_bytes) });
-    let mut multipart = Multipart::new(body_stream, boundary);
-    let mut collections = HashSet::new();
-    let mut file_count = 0;
-    let mut record_count = 0;
-
-    while let Some(field) = multipart.next_field().await.map_err(|_| StatusCode::BAD_REQUEST)? {
-        if field.name() == Some("lexicon_file") {
-            let data = field.bytes().await.map_err(|_| StatusCode::BAD_REQUEST)?;
-
-            // Parse zip file
-            let cursor = std::io::Cursor::new(data);
-            let mut archive = ZipArchive::new(cursor).map_err(|e| {
-                let err = LexiconError::ZipArchive(e.to_string());
-                error!("{}", err);
-                StatusCode::BAD_REQUEST
-            })?;
-
-
-            for i in 0..archive.len() {
-                let mut file = archive.by_index(i).map_err(|e| {
-                    let err = LexiconError::FileRead(format!("Failed to access file at index {}: {}", i, e));
-                    error!("{}", err);
-                    StatusCode::INTERNAL_SERVER_ERROR
-                })?;
-
-                // Only process JSON files, skip macOS metadata files
-                if file.name().ends_with(".json") &&
-                   !file.name().contains("__MACOSX") &&
-                   !file.name().starts_with("._") {
-
-                    let mut contents = String::new();
-                    if let Err(e) = file.read_to_string(&mut contents) {
-                        let err = LexiconError::FileRead(format!("Failed to read {}: {}", file.name(), e));
-                        warn!("{}", err);
-                        continue; // Skip this file and continue processing others
-                    }
-
-                    // Try to parse as lexicon
-                    match serde_json::from_str::<LexiconFile>(&contents) {
-                        Ok(lexicon_file) => {
-                            file_count += 1;
-
-                            // Look for record definitions first
-                            let mut has_record_def = false;
-                            for (_def_name, def_value) in &lexicon_file.defs {
-                                if let Some(def_obj) = def_value.as_object() {
-                                    if let Some(type_val) = def_obj.get("type") {
-                                        if type_val == "record" {
-                                            // This is a record definition - for AT Protocol listRecords, we only use the NSID
-                                            // Fragments (#definition) are for Lexicon references, not collection names
-                                            collections.insert(lexicon_file.id.clone());
-                                            record_count += 1;
-                                            has_record_def = true;
-                                        }
-                                    }
-                                }
-                            }
-
-                            // Only store lexicon in database if it has record definitions (will be synced)
-                            if has_record_def {
-                                let now = Utc::now();
-                                let lexicon = Lexicon {
-                                    nsid: lexicon_file.id.clone(),
-                                    definitions: serde_json::Value::Object(lexicon_file.defs.clone()),
-                                    created_at: now,
-                                    updated_at: now,
-                                };
-
-                                if let Err(e) = state.database.insert_lexicon(&lexicon).await {
-                                    warn!("Failed to store lexicon {}: {}", lexicon_file.id, e);
-                                }
-                            }
-                        }
-                        Err(e) => {
-                            let err = LexiconError::JsonParse(format!("Failed to parse {}: {}", file.name(), e));
-                            warn!("{}", err);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let collections_list: Vec<String> = collections.into_iter().collect();
-    let collections_str = collections_list.join(", ");
-
-    // Group collections by domain - create a vector of objects for template
-    let mut domain_groups: std::collections::BTreeMap<String, Vec<String>> = std::collections::BTreeMap::new();
-    for collection in &collections_list {
-        let domain = if let Some(dot_index) = collection.find('.') {
-            collection[..dot_index].to_string()
-        } else {
-            "other".to_string()
-        };
-        domain_groups.entry(domain).or_insert_with(Vec::new).push(collection.clone());
-    }
-
-    // Convert to a format that minijinja can handle
-    let grouped_collections: Vec<serde_json::Value> = domain_groups
-        .into_iter()
-        .map(|(domain, collections)| {
-            serde_json::json!({
-                "domain": domain,
-                "collections": collections
-            })
-        })
-        .collect();
-
-
-    let mut env = Environment::new();
-    env.add_template("upload_result.html", r#"
-        <div class="alert alert-success">
-            <h4>✅ Lexicon parsing completed!</h4>
-            <p><strong>Files processed:</strong> {{ file_count }}</p>
-            <p><strong>Record definitions found:</strong> {{ record_count }}</p>
-
-            <div class="mt-4">
-                <h5 class="font-medium text-gray-800 mb-2">Select Collections to Sync:</h5>
-                <div class="space-y-3">
-                    {% for group in grouped_collections %}
-                    <div class="border border-gray-200 rounded-lg p-3">
-                        <div class="flex items-center mb-2">
-                            <input type="checkbox"
-                                   id="domain-{{ group.domain }}"
-                                   class="domain-checkbox mr-2"
-                                   _="on change toggle .checked on .collection-{{ group.domain }} then call updateCollections()">
-                            <label for="domain-{{ group.domain }}" class="font-medium text-gray-700">{{ group.domain }}.*</label>
-                        </div>
-                        <div class="ml-6 space-y-1">
-                            {% for collection in group.collections %}
-                            <div class="flex items-center">
-                                <input type="checkbox"
-                                       id="collection-{{ collection }}"
-                                       class="collection-checkbox collection-{{ group.domain }} mr-2"
-                                       value="{{ collection }}"
-                                       _="on change call updateCollections()">
-                                <label for="collection-{{ collection }}" class="text-sm text-gray-600 font-mono">{{ collection }}</label>
-                            </div>
-                            {% endfor %}
-                        </div>
-                    </div>
-                    {% endfor %}
-                </div>
-
-                <div class="mt-4">
-                    <button class="bg-blue-500 text-white px-3 py-1 rounded text-sm mr-2"
-                            _="on click add .checked to .collection-checkbox then call updateCollections()">
-                        Select All
-                    </button>
-                    <button class="bg-gray-500 text-white px-3 py-1 rounded text-sm"
-                            _="on click remove .checked from .collection-checkbox then call updateCollections()">
-                        Select None
-                    </button>
-                </div>
-            </div>
-
-            <script>
-                function updateCollections() {
-                    const selectedCollections = Array.from(document.querySelectorAll('.collection-checkbox:checked'))
-                        .map(cb => cb.value);
-
-                    document.getElementById('collections').value = selectedCollections.join(', ');
-
-                    // Update domain checkboxes
-                    document.querySelectorAll('.domain-checkbox').forEach(domainCb => {
-                        const domain = domainCb.id.replace('domain-', '');
-                        const domainCollections = document.querySelectorAll('.collection-' + domain);
-                        const checkedDomainCollections = document.querySelectorAll('.collection-' + domain + ':checked');
-
-                        if (checkedDomainCollections.length === 0) {
-                            domainCb.checked = false;
-                            domainCb.indeterminate = false;
-                        } else if (checkedDomainCollections.length === domainCollections.length) {
-                            domainCb.checked = true;
-                            domainCb.indeterminate = false;
-                        } else {
-                            domainCb.checked = false;
-                            domainCb.indeterminate = true;
-                        }
-                    });
-                }
-
-                // Auto-populate with all collections initially and check all boxes
-                document.getElementById('collections').value = '{{ collections_str }}';
-                document.querySelectorAll('.collection-checkbox').forEach(cb => cb.checked = true);
-                document.querySelectorAll('.domain-checkbox').forEach(cb => cb.checked = true);
-            </script>
-        </div>
-    "#).unwrap();
-
-    let tmpl = env.get_template("upload_result.html").unwrap();
-    let rendered = tmpl.render(context! {
-        file_count => file_count,
-        record_count => record_count,
-        collections_str => collections_str,
-        grouped_collections => grouped_collections
-    }).unwrap();
-
-    Ok(Html(rendered))
-}

api/src/handler_xrpc_codegen.rs

···
 
 #[derive(Deserialize)]
 pub struct CodegenXrpcRequest {
+    #[allow(dead_code)]
     target: String,
-    client_type: String,
-    lexicons: Vec<String>,
+    slice: String, // at-uri of the slice to filter lexicons by
 }
 
 #[derive(Serialize)]
···
     State(state): State<AppState>,
     Json(request): Json<CodegenXrpcRequest>,
 ) -> Result<ResponseJson<CodegenXrpcResponse>, StatusCode> {
-    if request.lexicons.is_empty() {
-        return Ok(ResponseJson(CodegenXrpcResponse {
+    // Query database for lexicon definitions by slice
+    let lexicon_definitions = match state.database.get_lexicons_by_slice(&request.slice).await {
+        Ok(definitions) => definitions,
+        Err(_) => return Ok(ResponseJson(CodegenXrpcResponse {
             success: false,
             generated_code: None,
-            error: Some("No lexicons specified".to_string()),
-        }));
-    }
-
-    // Fetch the selected lexicons from database
-    let mut lexicons = Vec::new();
-    for nsid in &request.lexicons {
-        if let Ok(Some(lexicon)) = state.database.get_lexicon(nsid).await {
-            lexicons.push(lexicon);
-        }
-    }
+            error: Some("Failed to query lexicon records".to_string()),
+        }))
+    };
 
-    if lexicons.is_empty() {
+    if lexicon_definitions.is_empty() {
         return Ok(ResponseJson(CodegenXrpcResponse {
             success: false,
             generated_code: None,
-            error: Some("No valid lexicons found".to_string()),
+            error: Some(format!("No lexicons found for slice: {}", request.slice)),
         }));
     }
 
-    let generated_code = match request.target.as_str() {
-        "typescript-deno" => match request.client_type.as_str() {
-            "records" => {
-                let generator = TypeScriptGenerator::new();
-                match generator.generate_client(&lexicons) {
-                    Ok(code) => code,
-                    Err(e) => return Ok(ResponseJson(CodegenXrpcResponse {
-                        success: false,
-                        generated_code: None,
-                        error: Some(format!("TypeScript generation failed: {}", e)),
-                    })),
-                }
-            },
-            _ => return Ok(ResponseJson(CodegenXrpcResponse {
-                success: false,
-                generated_code: None,
-                error: Some("Unsupported client type".to_string()),
-            })),
-        },
-        _ => return Ok(ResponseJson(CodegenXrpcResponse {
+    // Pass lexicon definitions to TypeScript generator
+    let generator = TypeScriptGenerator::new();
+    let lexicons_json = serde_json::to_string(&lexicon_definitions).unwrap_or_default();
+    
+    match generator.generate_client(&lexicons_json) {
+        Ok(code) => Ok(ResponseJson(CodegenXrpcResponse {
+            success: true,
+            generated_code: Some(code),
+            error: None,
+        })),
+        Err(e) => Ok(ResponseJson(CodegenXrpcResponse {
             success: false,
             generated_code: None,
-            error: Some("Unsupported target".to_string()),
-        })),
-    };
-
-    Ok(ResponseJson(CodegenXrpcResponse {
-        success: true,
-        generated_code: Some(generated_code),
-        error: None,
-    }))
+            error: Some(e),
+        }))
+    }
 }

api/src/main.rs

···
 mod codegen;
 mod database;
 mod errors;
-mod handler_codegen;
-mod handler_dynamic_xrpc;
-mod handler_lexicon;
-mod handler_upload_lexicon;
+mod handler_sync;
 mod handler_xrpc_codegen;
+mod handler_xrpc_dynamic;
 mod models;
 mod sync;
 mod utils;
-mod web;
 
 use axum::{
     Router,
-    extract::{Query, State},
-    http::StatusCode,
-    response::Json,
     routing::{get, post},
 };
 use sqlx::PgPool;
···
 
 use crate::database::Database;
 use crate::errors::AppError;
-use crate::models::{
-    BulkSyncOutput, BulkSyncParams, ListRecordsOutput, ListRecordsParams, SmartSyncParams,
-};
 use crate::sync::SyncService;
-use crate::web::WebService;
 
 #[derive(Clone)]
 pub struct Config {
···
 pub struct AppState {
     database: Database,
     sync_service: SyncService,
-    #[allow(dead_code)]
-    web_service: WebService,
     config: Config,
 }
 
···
 
     let database = Database::new(pool);
     let sync_service = SyncService::new(database.clone());
-    let web_service = WebService::new();
 
     let auth_base_url = env::var("AUTH_BASE_URL")
         .unwrap_or_else(|_| "https://auth.grainsocial.network".to_string());
 
-    let config = Config {
-        auth_base_url,
-    };
+    let config = Config { auth_base_url };
 
     let state = AppState {
         database: database.clone(),
         sync_service,
-        web_service,
         config,
     };
 
     // Build application with routes
     let app = Router::new()
         // XRPC endpoints
-        .route("/xrpc/social.slices.records.list", get(list_records))
-        .route("/xrpc/social.slices.collections.bulkSync", post(bulk_sync))
-        .route("/xrpc/social.slices.repos.smartSync", post(smart_sync))
+        .route("/xrpc/social.slices.slice.sync", post(handler_sync::sync))
         .route(
-            "/xrpc/social.slices.codegen.generate",
+            "/xrpc/social.slices.slice.codegen",
             post(handler_xrpc_codegen::generate_client_xrpc),
         )
         // Dynamic collection-specific XRPC endpoints
         .route(
             "/xrpc/*method",
-            get(handler_dynamic_xrpc::dynamic_xrpc_handler),
+            get(handler_xrpc_dynamic::dynamic_xrpc_handler),
         )
         .route(
             "/xrpc/*method",
-            post(handler_dynamic_xrpc::dynamic_xrpc_post_handler),
-        )
-        // Web interface
-        .route("/", get(web::index))
-        .route("/records", get(web::records_page))
-        .route("/sync", get(web::sync_page))
-        .route("/sync", post(web::bulk_sync_action))
-        .route("/codegen", get(web::codegen_page))
-        .route("/codegen/generate", post(handler_codegen::generate_client))
-        .route("/lexicon", get(handler_lexicon::lexicon_page))
-        .route(
-            "/upload-lexicons",
-            post(handler_upload_lexicon::upload_lexicons),
+            post(handler_xrpc_dynamic::dynamic_xrpc_post_handler),
         )
         .layer(TraceLayer::new_for_http())
         .layer(CorsLayer::permissive())
···
     Ok(())
 }
 
-async fn list_records(
-    State(state): State<AppState>,
-    Query(params): Query<ListRecordsParams>,
-) -> Result<Json<ListRecordsOutput>, StatusCode> {
-    match state.database.list_records(params).await {
-        Ok(records) => Ok(Json(ListRecordsOutput {
-            records,
-            cursor: None, // TODO: implement cursor pagination
-        })),
-        Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
-    }
-}
 
-async fn bulk_sync(
-    State(state): State<AppState>,
-    axum::extract::Json(params): axum::extract::Json<BulkSyncParams>,
-) -> Result<Json<BulkSyncOutput>, StatusCode> {
-    match state
-        .sync_service
-        .backfill_collections(&params.collections, params.repos.as_deref())
-        .await
-    {
-        Ok(_) => {
-            let total_records = state.database.get_total_record_count().await.unwrap_or(0);
-            Ok(Json(BulkSyncOutput {
-                success: true,
-                total_records,
-                collections_synced: params.collections,
-                repos_processed: params.repos.map(|r| r.len() as i64).unwrap_or(0),
-                message: "Bulk sync completed successfully".to_string(),
-            }))
-        }
-        Err(e) => Ok(Json(BulkSyncOutput {
-            success: false,
-            total_records: 0,
-            collections_synced: vec![],
-            repos_processed: 0,
-            message: format!("Bulk sync failed: {}", e),
-        })),
-    }
-}
-
-async fn smart_sync(
-    State(state): State<AppState>,
-    axum::extract::Json(params): axum::extract::Json<SmartSyncParams>,
-) -> Result<Json<BulkSyncOutput>, StatusCode> {
-    let collections = params.collections.as_deref();
-
-    match state.sync_service.sync_repo(&params.did, collections).await {
-        Ok(records_count) => {
-            let total_records = state.database.get_total_record_count().await.unwrap_or(0);
-            Ok(Json(BulkSyncOutput {
-                success: true,
-                total_records,
-                collections_synced: params.collections.unwrap_or_default(),
-                repos_processed: 1,
-                message: format!(
-                    "Smart sync completed for {}: {} records",
-                    params.did, records_count
-                ),
-            }))
-        }
-        Err(e) => Ok(Json(BulkSyncOutput {
-            success: false,
-            total_records: 0,
-            collections_synced: vec![],
-            repos_processed: 0,
-            message: format!("Smart sync failed for {}: {}", params.did, e),
-        })),
-    }
-}

api/src/models.rs

···
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct CreateRecordInput {
-    pub collection: String,
-    pub repo: String,
-    pub rkey: Option<String>,
-    pub record: Value,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateRecordOutput {
+pub struct IndexedRecord {
     pub uri: String,
     pub cid: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ListRecordsParams {
+    pub did: String,
     pub collection: String,
-    pub author: Option<String>,
-    pub limit: Option<i32>,
-    pub cursor: Option<String>,
+    pub value: Value,
+    #[serde(rename = "indexedAt")]
+    pub indexed_at: String,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
···
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct IndexedRecord {
-    pub uri: String,
-    pub cid: String,
-    pub did: String,
-    pub collection: String,
-    pub value: Value,
-    #[serde(rename = "indexedAt")]
-    pub indexed_at: String,
-}
-
-
-#[derive(Debug, Serialize, Deserialize)]
 pub struct BulkSyncParams {
     pub collections: Vec<String>,
     pub repos: Option<Vec<String>>,
···
     pub collections_synced: Vec<String>,
     pub repos_processed: i64,
     pub message: String,
-}
-
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct SmartSyncParams {
-    pub did: String,
-    pub collections: Option<Vec<String>>,
-    pub force_full_sync: Option<bool>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
-pub struct Lexicon {
-    pub nsid: String,
-    pub definitions: serde_json::Value,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]

api/src/sync.rs

···
         }
     }
 
-    // Sync using listRecords
-    pub async fn sync_repo(&self, did: &str, collections: Option<&[String]>) -> Result<i64, SyncError> {
-        info!("🔄 Starting sync for DID: {}", did);
-
-        let total_records = self.listrecords_sync(did, collections).await?;
-
-        info!("✅ Sync completed for {}: {} records", did, total_records);
-        Ok(total_records)
-    }
-
-
-    // Sync using listRecords
-    async fn listrecords_sync(&self, did: &str, collections: Option<&[String]>) -> Result<i64, SyncError> {
-        let collections_to_sync = match collections {
-            Some(cols) => cols,
-            None => return Ok(0), // No collections specified = no records
-        };
-
-        // Get ATP data for this single repo
-        let atp_map = self.get_atp_map_for_repos(&[did.to_string()]).await?;
-
-        let mut total_records = 0;
-        for collection in collections_to_sync {
-            match self.fetch_records_for_repo_collection_with_atp_map(did, collection, &atp_map).await {
-                Ok(records) => {
-                    if !records.is_empty() {
-                        info!("📋 Fallback sync: {} records for {}/{}", records.len(), did, collection);
-                        self.database.batch_insert_records(&records).await?;
-                        total_records += records.len() as i64;
-                    }
-                }
-                Err(e) => {
-                    error!("Failed fallback sync for {}/{}: {}", did, collection, e);
-                }
-            }
-        }
-
-        Ok(total_records)
-    }
 
 
     pub async fn backfill_collections(&self, collections: &[String], repos: Option<&[String]>) -> Result<(), SyncError> {

api/src/web.rs

···
-use axum::{
-    extract::{Query, State},
-    http::StatusCode,
-    response::{Html, IntoResponse},
-    Form,
-};
-use minijinja::{context, Environment};
-use serde::Deserialize;
-use std::collections::HashMap;
-
-use crate::models::ListRecordsParams;
-use crate::AppState;
-
-#[derive(Clone)]
-pub struct WebService {
-    #[allow(dead_code)]
-    env: Environment<'static>,
-}
-
-impl WebService {
-    pub fn new() -> Self {
-        let mut env = Environment::new();
-
-        // Add base template
-        env.add_template("base.html", include_str!("../templates/base.html")).unwrap();
-        env.add_template("index.html", include_str!("../templates/index.html")).unwrap();
-        env.add_template("records.html", include_str!("../templates/records.html")).unwrap();
-        env.add_template("sync.html", include_str!("../templates/sync.html")).unwrap();
-
-        Self { env }
-    }
-}
-
-#[derive(Deserialize)]
-pub struct BulkSyncForm {
-    collections: String,
-    repos: Option<String>,
-}
-
-
-pub async fn index(State(state): State<AppState>) -> Result<impl IntoResponse, StatusCode> {
-    let collections = state.database.get_available_collections().await.unwrap_or_default();
-    let total_records = state.database.get_total_record_count().await.unwrap_or(0);
-
-    let mut env = Environment::new();
-    env.add_template("base.html", include_str!("../templates/base.html")).unwrap();
-    env.add_template("index.html", include_str!("../templates/index.html")).unwrap();
-
-    let tmpl = env.get_template("index.html").unwrap();
-    let rendered = tmpl.render(context! {
-        title => "AT Protocol Indexer",
-        collections => collections,
-        total_records => total_records
-    }).unwrap();
-
-    Ok(Html(rendered))
-}
-
-pub async fn records_page(
-    State(state): State<AppState>,
-    Query(params): Query<HashMap<String, String>>,
-) -> Result<impl IntoResponse, StatusCode> {
-    let collection = params.get("collection").cloned().unwrap_or_default();
-    let author = params.get("author").cloned();
-
-    // Get available collections for the dropdown
-    let available_collections = state.database.get_available_collections().await.unwrap_or_default();
-
-    let records = if !collection.is_empty() {
-        let list_params = ListRecordsParams {
-            collection: collection.clone(),
-            author,
-            limit: Some(50),
-            cursor: None,
-        };
-        let raw_records = state.database.list_records(list_params).await.unwrap_or_default();
-
-        // Transform records to include pretty-printed JSON
-        raw_records.into_iter().map(|record| {
-            let pretty_json = serde_json::to_string_pretty(&record.value).unwrap_or_else(|_| record.value.to_string());
-            serde_json::json!({
-                "uri": record.uri,
-                "cid": record.cid,
-                "did": record.did,
-                "collection": record.collection,
-                "value": record.value,
-                "pretty_value": pretty_json,
-                "indexed_at": record.indexed_at
-            })
-        }).collect()
-    } else {
-        Vec::new()
-    };
-
-    let mut env = Environment::new();
-    env.add_template("base.html", include_str!("../templates/base.html")).unwrap();
-    env.add_template("records.html", include_str!("../templates/records.html")).unwrap();
-
-    let tmpl = env.get_template("records.html").unwrap();
-    let rendered = tmpl.render(context! {
-        title => "Records",
-        records => records,
-        collection => collection,
-        available_collections => available_collections
-    }).unwrap();
-
-    Ok(Html(rendered))
-}
-
-pub async fn codegen_page(State(state): State<AppState>) -> Result<impl IntoResponse, StatusCode> {
-    // Get stored lexicons for the UI
-    let lexicons = match state.database.get_all_lexicons().await {
-        Ok(lexicons) => lexicons,
-        Err(_) => Vec::new(),
-    };
-
-    let mut env = Environment::new();
-    env.add_template("base.html", include_str!("../templates/base.html")).unwrap();
-    env.add_template("codegen.html", include_str!("../templates/codegen.html")).unwrap();
-
-    let tmpl = env.get_template("codegen.html").unwrap();
-    let rendered = tmpl.render(context! {
-        title => "Client Code Generation",
-        lexicons => lexicons
-    }).unwrap();
-
-    Ok(Html(rendered))
-}
-
-pub async fn sync_page() -> impl IntoResponse {
-    let mut env = Environment::new();
-    env.add_template("base.html", include_str!("../templates/base.html")).unwrap();
-    env.add_template("sync.html", include_str!("../templates/sync.html")).unwrap();
-
-    let tmpl = env.get_template("sync.html").unwrap();
-    let rendered = tmpl.render(context! {
-        title => "Sync Records"
-    }).unwrap();
-
-    Html(rendered)
-}
-
-pub async fn bulk_sync_action(
-    State(state): State<AppState>,
-    Form(form): Form<BulkSyncForm>,
-) -> Result<impl IntoResponse, StatusCode> {
-    // Parse collections from comma-separated string
-    let collections: Vec<String> = form.collections
-        .split(',')
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty())
-        .collect();
-
-    // Parse repos from newline-separated string if provided
-    let repos = form.repos
-        .filter(|s| !s.trim().is_empty())
-        .map(|s| s.lines()
-            .map(|line| line.trim().to_string())
-            .filter(|line| !line.is_empty())
-            .collect::<Vec<String>>());
-
-    if collections.is_empty() {
-        return Ok(Html(r#"
-            <div class="alert alert-error">
-                <h4>❌ No collections specified</h4>
-                <p>Please specify at least one collection to sync.</p>
-            </div>
-        "#.to_string()));
-    }
-
-    match state.sync_service.backfill_collections(&collections, repos.as_deref()).await {
-        Ok(_) => {
-            let total_records = state.database.get_total_record_count().await.unwrap_or(0);
-
-            let mut env = Environment::new();
-            env.add_template("sync_result.html", r#"
-                <div class="alert alert-success">
-                    <h4>✅ Bulk sync completed successfully!</h4>
-                    <p><strong>Collections synced:</strong> {{ collections|join(", ") }}</p>
-                    <p><strong>Total records in database:</strong> {{ total_records }}</p>
-                    <p><strong>Operation:</strong> {{ message }}</p>
-                </div>
-            "#).unwrap();
-
-            let tmpl = env.get_template("sync_result.html").unwrap();
-            let rendered = tmpl.render(context! {
-                collections => collections,
-                total_records => total_records,
-                message => "Bulk sync operation completed"
-            }).unwrap();
-
-            Ok(Html(rendered))
-        },
-        Err(e) => {
-            Ok(Html(format!(r#"
-                <div class="alert alert-error">
-                    <h4>❌ Bulk sync failed</h4>
-                    <p>Error: {}</p>
-                </div>
-            "#, e)))
-        }
-    }
-}
-

api/templates/base.html

···
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>{{ title }} - AT Protocol Indexer</title>
-    <script src="https://unpkg.com/htmx.org@1.9.10"></script>
-    <script src="https://unpkg.com/hyperscript.org@0.9.12"></script>
-    <script src="https://cdn.tailwindcss.com/3.4.1"></script>
-    <style>
-        .alert {
-            padding: 1rem;
-            margin-bottom: 1rem;
-            border-radius: 0.375rem;
-            border-width: 1px;
-        }
-
-        .alert-success {
-            background-color: #dcfce7;
-            border-color: #22c55e;
-            color: #15803d;
-        }
-
-        .alert-warning {
-            background-color: #fef3c7;
-            border-color: #eab308;
-            color: #a16207;
-        }
-
-        .alert-error {
-            background-color: #fecaca;
-            border-color: #ef4444;
-            color: #dc2626;
-        }
-
-        .htmx-indicator {
-            display: none;
-        }
-
-        .htmx-request .htmx-indicator {
-            display: inline;
-        }
-
-        .htmx-request .default-text {
-            display: none;
-        }
-    </style>
-</head>
-
-<body class="bg-gray-100 min-h-screen">
-    <nav class="bg-blue-600 text-white p-4">
-        <div class="container mx-auto flex justify-between items-center">
-            <h1 class="text-xl font-bold">AT Protocol Indexer</h1>
-            <div class="space-x-4">
-                <a href="/" class="hover:underline">Home</a>
-                <a href="/records" class="hover:underline">Records</a>
-                <a href="/lexicon" class="hover:underline">Lexicon</a>
-                <a href="/sync" class="hover:underline">Sync</a>
-                <a href="/codegen" class="hover:underline">Codegen</a>
-            </div>
-        </div>
-    </nav>
-
-    <main class="container mx-auto mt-8 px-4">
-        {% block content %}{% endblock %}
-    </main>
-</body>
-
-</html>

api/templates/codegen.html

···
-{% extends "base.html" %}
-
-{% block content %}
-<div class="max-w-6xl mx-auto">
-    <h1 class="text-3xl font-bold text-gray-800 mb-8">Client Code Generation</h1>
-    
-    <div class="bg-white rounded-lg shadow-md p-6 mb-6">
-        <h2 class="text-xl font-semibold mb-4">Generate Typed Clients</h2>
-        <p class="text-gray-600 mb-6">Generate TypeScript clients for interacting with XRPC APIs based on stored lexicon definitions.</p>
-        
-        <form hx-post="/codegen/generate" 
-              hx-target="#codegen-result" 
-              hx-indicator="#generate-button"
-              class="space-y-6">
-            <div>
-                <label for="target" class="block text-sm font-medium text-gray-700 mb-2">Target Language</label>
-                <select name="target" id="target" class="w-full border border-gray-300 rounded-md px-3 py-2">
-                    <option value="typescript-deno">TypeScript (Deno)</option>
-                </select>
-            </div>
-            
-            <div>
-                <label for="client_type" class="block text-sm font-medium text-gray-700 mb-2">Client Type</label>
-                <select name="client_type" id="client_type" class="w-full border border-gray-300 rounded-md px-3 py-2">
-                    <option value="records">Records Client</option>
-                </select>
-            </div>
-            
-            <div>
-                <label class="block text-sm font-medium text-gray-700 mb-2">Include Collections</label>
-                <div class="space-y-2 max-h-64 overflow-y-auto border border-gray-300 rounded-md p-3">
-                    {% if lexicons %}
-                        {% for lexicon in lexicons %}
-                        <div class="flex items-center">
-                            <input type="checkbox" 
-                                   id="lexicon-{{ lexicon.nsid }}" 
-                                   name="lexicons" 
-                                   value="{{ lexicon.nsid }}"
-                                   class="mr-2">
-                            <label for="lexicon-{{ lexicon.nsid }}" class="text-sm text-gray-600 font-mono">{{ lexicon.nsid }}</label>
-                        </div>
-                        {% endfor %}
-                    {% else %}
-                        <p class="text-gray-500 text-sm">No lexicons available. Upload some lexicon files first.</p>
-                    {% endif %}
-                </div>
-            </div>
-            
-            <button type="submit" 
-                    id="generate-button"
-                    class="w-full bg-green-500 hover:bg-green-600 text-white px-6 py-3 rounded-md font-medium">
-                <span class="default-text">Generate Client</span>
-                <span class="htmx-indicator">🔄 Generating...</span>
-            </button>
-        </form>
-        
-        <div id="codegen-result" class="mt-6"></div>
-    </div>
-    
-    <div class="bg-blue-50 border border-blue-200 rounded-lg p-6">
-        <h3 class="text-lg font-semibold text-blue-800 mb-2">💡 About Client Generation</h3>
-        <ul class="space-y-2 text-blue-700">
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Generates typed TypeScript clients for interacting with XRPC APIs</span>
-            </li>
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Based on stored lexicon definitions with full type safety</span>
-            </li>
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Includes interfaces for records, queries, and procedures</span>
-            </li>
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Compatible with Deno and modern TypeScript environments</span>
-            </li>
-        </ul>
-    </div>
-</div>
-{% endblock %}

api/templates/index.html

···
-{% extends "base.html" %}
-
-{% block content %}
-<div class="max-w-4xl mx-auto">
-  <h1 class="text-3xl font-bold text-gray-800 mb-8">AT Protocol Indexer</h1>
-
-  {% if total_records > 0 %}
-  <div class="bg-blue-50 border border-blue-200 rounded-lg p-6 mb-8">
-    <h2 class="text-xl font-semibold text-blue-800 mb-2">📊 Database Status</h2>
-    <p class="text-blue-700">Currently indexing <strong>{{ total_records }}</strong> records across <strong>{{
-        collections|length }}</strong> collections.</p>
-  </div>
-  {% endif %}
-
-  <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
-    <div class="bg-white rounded-lg shadow-md p-6">
-      <h2 class="text-xl font-semibold text-gray-800 mb-4">📝 View Records</h2>
-      <p class="text-gray-600 mb-4">Browse indexed AT Protocol records by collection.</p>
-      {% if collections %}
-      <a href="/records" class="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded">
-        Browse Records
-      </a>
-      {% else %}
-      <p class="text-gray-500 text-sm">No records synced yet. Start by syncing some records!</p>
-      {% endif %}
-    </div>
-
-    <div class="bg-white rounded-lg shadow-md p-6">
-      <h2 class="text-xl font-semibold text-gray-800 mb-4">📚 Lexicon Definitions</h2>
-      <p class="text-gray-600 mb-4">View lexicon definitions and schemas.</p>
-      <a href="/lexicon" class="bg-purple-500 hover:bg-purple-600 text-white px-4 py-2 rounded">
-        View Lexicons
-      </a>
-    </div>
-
-    <div class="bg-white rounded-lg shadow-md p-6">
-      <h2 class="text-xl font-semibold text-gray-800 mb-4">⚡ Code Generation</h2>
-      <p class="text-gray-600 mb-4">Generate TypeScript client from your lexicon definitions.</p>
-      <a href="/codegen" class="bg-orange-500 hover:bg-orange-600 text-white px-4 py-2 rounded">
-        Generate Client
-      </a>
-    </div>
-
-    <div class="bg-white rounded-lg shadow-md p-6">
-      <h2 class="text-xl font-semibold text-gray-800 mb-4">🔄 Bulk Sync</h2>
-      <p class="text-gray-600 mb-4">Sync entire collections from AT Protocol networks.</p>
-      <a href="/sync" class="bg-green-500 hover:bg-green-600 text-white px-4 py-2 rounded">
-        Start Bulk Sync
-      </a>
-    </div>
-
-    {% if collections %}
-    <div class="bg-white rounded-lg shadow-md p-6">
-      <h2 class="text-xl font-semibold text-gray-800 mb-4">📊 Synced Collections</h2>
-      <p class="text-gray-600 mb-4">Collections currently indexed in the database.</p>
-      <div class="space-y-2 max-h-40 overflow-y-auto">
-        {% for collection in collections %}
-        <a href="/records?collection={{ collection[0] }}"
-          class="flex justify-between items-center text-blue-600 hover:underline text-sm">
-          <span>{{ collection[0] }}</span>
-          <span class="text-gray-500">{{ collection[1] }}</span>
-        </a>
-        {% endfor %}
-      </div>
-    </div>
-    {% else %}
-    <div class="bg-white rounded-lg shadow-md p-6">
-      <h2 class="text-xl font-semibold text-gray-800 mb-4">🌟 Get Started</h2>
-      <p class="text-gray-600 mb-4">No records indexed yet. Start by syncing some AT Protocol collections!</p>
-      <div class="space-y-2 text-sm">
-        <p class="text-gray-500">Try syncing collections like:</p>
-        <code class="block bg-gray-100 p-2 rounded text-xs">app.bsky.feed.post</code>
-        <code class="block bg-gray-100 p-2 rounded text-xs">app.bsky.actor.profile</code>
-      </div>
-    </div>
-    {% endif %}
-  </div>
-
-  <div class="mt-12 bg-white rounded-lg shadow-md p-6">
-    <h2 class="text-2xl font-semibold text-gray-800 mb-4">API Endpoints</h2>
-    <div class="space-y-4">
-      <div>
-        <code
-          class="bg-gray-100 px-2 py-1 rounded">GET /xrpc/social.slices.records.list?collection=app.bsky.feed.post</code>
-        <p class="text-gray-600 mt-1">List records for a collection</p>
-      </div>
-      <div>
-        <code class="bg-gray-100 px-2 py-1 rounded">POST /xrpc/social.slices.collections.bulkSync</code>
-        <p class="text-gray-600 mt-1">Bulk sync collections (JSON: {"collections": ["app.bsky.feed.post"]})</p>
-      </div>
-    </div>
-  </div>
-</div>
-{% endblock %}

api/templates/lexicon.html

···
-{% extends "base.html" %}
-
-{% block content %}
-<div class="max-w-6xl mx-auto">
-    <h1 class="text-3xl font-bold text-gray-800 mb-8">Lexicon Definitions</h1>
-    
-    {% if lexicons %}
-    <div class="bg-white rounded-lg shadow-md overflow-hidden">
-        <div class="px-6 py-4 bg-gray-50 border-b">
-            <h3 class="text-lg font-semibold">Found {{ lexicons|length }} lexicon definitions</h3>
-        </div>
-        <div class="divide-y divide-gray-200">
-            {% for lexicon in lexicons %}
-            <div class="p-6">
-                <div class="flex justify-between items-start mb-4">
-                    <h4 class="text-lg font-medium text-blue-600">{{ lexicon.nsid }}</h4>
-                    <span class="text-xs text-gray-500">Updated: {{ lexicon.updated_at }}</span>
-                </div>
-                
-                <div class="mt-4">
-                    <details class="cursor-pointer">
-                        <summary class="font-medium text-gray-700 hover:text-gray-900">View Definitions</summary>
-                        <div class="mt-4">
-                            {% if lexicon.pretty_definitions %}
-                                <pre class="bg-gray-100 p-3 rounded text-xs overflow-x-auto">{{ lexicon.pretty_definitions }}</pre>
-                            {% else %}
-                                <p class="text-gray-500 italic">No definitions found</p>
-                            {% endif %}
-                        </div>
-                    </details>
-                </div>
-            </div>
-            {% endfor %}
-        </div>
-    </div>
-    {% else %}
-    <div class="bg-white rounded-lg shadow-md p-8 text-center">
-        <div class="text-gray-400 text-6xl mb-4">📚</div>
-        <h3 class="text-xl font-semibold text-gray-800 mb-2">No lexicon definitions found</h3>
-        <p class="text-gray-600 mb-4">
-            Upload lexicon files to see their definitions here.
-        </p>
-        <a href="/sync" class="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded">
-            Upload Lexicons
-        </a>
-    </div>
-    {% endif %}
-</div>
-{% endblock %}

api/templates/records.html

···
-{% extends "base.html" %}
-
-{% block content %}
-<div class="max-w-6xl mx-auto">
-    <h1 class="text-3xl font-bold text-gray-800 mb-8">Records</h1>
-
-    <div class="bg-white rounded-lg shadow-md p-6 mb-6">
-        <div class="flex justify-between items-center mb-4">
-            <h2 class="text-xl font-semibold">Filter Records</h2>
-        </div>
-        <form class="grid grid-cols-1 md:grid-cols-3 gap-4" method="get" _="on submit 
-                 if #author.value is empty 
-                   remove @name from #author 
-                 end">
-            <div>
-                <label class="block text-sm font-medium text-gray-700 mb-2">Collection</label>
-                <select name="collection" class="w-full border border-gray-300 rounded-md px-3 py-2">
-                    <option value="">Select collection...</option>
-                    {% for available_collection in available_collections %}
-                    <option value="{{ available_collection[0] }}" {% if collection==available_collection[0] %}selected{%
-                        endif %}>
-                        {{ available_collection[0] }} ({{ available_collection[1] }} records)
-                    </option>
-                    {% endfor %}
-                </select>
-            </div>
-            <div>
-                <label class="block text-sm font-medium text-gray-700 mb-2">Author DID</label>
-                <input type="text" id="author" name="author" placeholder="did:plc:..."
-                    class="w-full border border-gray-300 rounded-md px-3 py-2">
-            </div>
-            <div class="flex items-end">
-                <button type="submit" class="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded-md">
-                    Filter
-                </button>
-            </div>
-        </form>
-    </div>
-
-    {% if records %}
-    <div class="bg-white rounded-lg shadow-md overflow-hidden">
-        <div class="px-6 py-4 bg-gray-50 border-b">
-            <h3 class="text-lg font-semibold">Found {{ records|length }} records</h3>
-        </div>
-        <div class="divide-y divide-gray-200">
-            {% for record in records %}
-            <div class="p-6">
-                <div class="flex justify-between items-start mb-2">
-                    <h4 class="text-sm font-medium text-blue-600">{{ record.uri }}</h4>
-                    <span class="text-xs text-gray-500">{{ record.indexed_at }}</span>
-                </div>
-                <div class="space-y-2 text-sm">
-                    <div>
-                        <span class="font-medium">Collection:</span>
-                        <span class="text-gray-600">{{ record.collection }}</span>
-                    </div>
-                    <div>
-                        <span class="font-medium">Author:</span>
-                        <span class="text-gray-600">{{ record.did }}</span>
-                    </div>
-                    <div>
-                        <span class="font-medium">CID:</span>
-                        <span class="text-gray-600 font-mono text-xs">{{ record.cid }}</span>
-                    </div>
-                </div>
-                {% if record.value %}
-                <div class="mt-4">
-                    <details class="cursor-pointer">
-                        <summary class="font-medium text-gray-700 hover:text-gray-900">View Record Data</summary>
-                        <pre
-                            class="mt-2 bg-gray-100 p-3 rounded text-xs overflow-x-auto">{{ record.pretty_value }}</pre>
-                    </details>
-                </div>
-                {% endif %}
-            </div>
-            {% endfor %}
-        </div>
-    </div>
-    {% else %}
-    <div class="bg-white rounded-lg shadow-md p-8 text-center">
-        <div class="text-gray-400 text-6xl mb-4">📝</div>
-        <h3 class="text-xl font-semibold text-gray-800 mb-2">No records found</h3>
-        <p class="text-gray-600 mb-4">
-            {% if collection %}
-            No records found for collection "{{ collection }}".
-            {% elif available_collections %}
-            Select a collection from the dropdown above to view records.
-            {% else %}
-            No records have been synced yet. Start by syncing some AT Protocol records!
-            {% endif %}
-        </p>
-        <a href="/sync" class="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded">
-            Sync Some Records
-        </a>
-    </div>
-    {% endif %}
-</div>
-{% endblock %}

api/templates/sync.html

···
-{% extends "base.html" %}
-
-{% block content %}
-<div class="max-w-4xl mx-auto">
-    <h1 class="text-3xl font-bold text-gray-800 mb-8">Sync Records</h1>
-    
-    <div class="max-w-2xl mx-auto">
-        <!-- Lexicon Upload Section -->
-        <div class="bg-white rounded-lg shadow-md p-6 mb-6">
-            <h2 class="text-xl font-semibold text-gray-800 mb-4">📦 Upload Lexicon Files</h2>
-            <p class="text-gray-600 mb-6">Upload a zip file containing lexicon JSON files to automatically populate collections for syncing.</p>
-            
-            <form hx-post="/upload-lexicons" 
-                  hx-target="#lexicon-result" 
-                  hx-indicator="#upload-button"
-                  enctype="multipart/form-data"
-                  class="space-y-4">
-                <div>
-                    <label for="lexicon-file" class="block text-sm font-medium text-gray-700 mb-2">Lexicon Zip File</label>
-                    <input type="file" 
-                           id="lexicon-file" 
-                           name="lexicon_file" 
-                           accept=".zip"
-                           class="w-full border border-gray-300 rounded-md px-3 py-2 focus:ring-2 focus:ring-green-500 focus:border-green-500"
-                           required>
-                    <p class="text-xs text-gray-500 mt-1">
-                        Upload a zip file containing lexicon JSON files. Record definitions will be extracted automatically.
-                    </p>
-                </div>
-                
-                <button type="submit" 
-                        id="upload-button"
-                        class="w-full bg-green-500 hover:bg-green-600 text-white px-6 py-3 rounded-md font-medium">
-                    <span class="default-text">Parse Lexicons</span>
-                    <span class="htmx-indicator">🔄 Processing...</span>
-                </button>
-            </form>
-            
-            <div id="lexicon-result" class="mt-4"></div>
-        </div>
-
-        <!-- Bulk Sync Section -->
-        <div class="bg-white rounded-lg shadow-md p-6">
-            <h2 class="text-xl font-semibold text-gray-800 mb-4">📚 Bulk Sync Collections</h2>
-            <p class="text-gray-600 mb-6">Sync multiple records from AT Protocol collections. This will fetch records from across the network.</p>
-            
-            <form hx-post="/sync" 
-                  hx-target="#sync-result" 
-                  hx-indicator="#sync-button"
-                  class="space-y-6">
-                <div>
-                    <label for="collections" class="block text-sm font-medium text-gray-700 mb-2">Collections to Sync</label>
-                    <input type="text" 
-                           id="collections" 
-                           name="collections" 
-                           placeholder="app.bsky.feed.post, app.bsky.actor.profile"
-                           class="w-full border border-gray-300 rounded-md px-3 py-2 focus:ring-2 focus:ring-blue-500 focus:border-blue-500"
-                           required>
-                    <p class="text-xs text-gray-500 mt-1">
-                        Enter collection names separated by commas. Common collections: app.bsky.feed.post, app.bsky.actor.profile, app.bsky.feed.like
-                    </p>
-                </div>
-                
-                <div>
-                    <label for="repos" class="block text-sm font-medium text-gray-700 mb-2">Specific DIDs (optional)</label>
-                    <textarea id="repos" 
-                              name="repos" 
-                              placeholder="did:plc:example1&#10;did:plc:example2"
-                              rows="4"
-                              class="w-full border border-gray-300 rounded-md px-3 py-2 focus:ring-2 focus:ring-blue-500 focus:border-blue-500"></textarea>
-                    <p class="text-xs text-gray-500 mt-1">Optional: Enter specific DIDs (one per line). Leave empty to discover and sync from all repositories that have the specified collections.</p>
-                </div>
-                
-                <div class="bg-yellow-50 border border-yellow-200 rounded-lg p-4">
-                    <div class="flex">
-                        <div class="flex-shrink-0">
-                            <span class="text-yellow-600">⚠️</span>
-                        </div>
-                        <div class="ml-3">
-                            <h3 class="text-sm font-medium text-yellow-800">Note about bulk sync</h3>
-                            <div class="mt-2 text-sm text-yellow-700">
-                                <p>Bulk sync can take several minutes and may fetch thousands of records. The operation runs in the foreground, so please be patient.</p>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-                
-                <button type="submit" 
-                        id="sync-button"
-                        class="w-full bg-blue-500 hover:bg-blue-600 text-white px-6 py-3 rounded-md font-medium">
-                    <span class="default-text">Start Bulk Sync</span>
-                    <span class="htmx-indicator">🔄 Syncing...</span>
-                </button>
-            </form>
-            
-            <div id="sync-result" class="mt-6"></div>
-        </div>
-    </div>
-    
-    <div class="mt-8 bg-blue-50 border border-blue-200 rounded-lg p-6">
-        <h3 class="text-lg font-semibold text-blue-800 mb-2">💡 Tips for Bulk Sync</h3>
-        <ul class="space-y-2 text-blue-700">
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Start with popular collections like <code class="bg-blue-100 px-1 rounded">app.bsky.feed.post</code> for posts</span>
-            </li>
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Leave DIDs empty to discover all repositories automatically</span>
-            </li>
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Use the API endpoint for programmatic access: <code class="bg-blue-100 px-1 rounded">/xrpc/social.slices.collections.bulkSync</code></span>
-            </li>
-            <li class="flex items-start">
-                <span class="font-bold mr-2">•</span>
-                <span>Sync operations may take time - progress is logged to the server console</span>
-            </li>
-        </ul>
-    </div>
-</div>
-{% endblock %}

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-08-21 22:15:58 UTC
+// Generated at: 2025-08-22 22:17:55 UTC
 // Lexicons: 2
 
 export interface OAuthAuthorizeParams {
···
   getRecord(params: GetRecordParams): Promise<RecordResponse<T>>;
 }
 
-export interface XyzSliceatLexiconRecord {
-  /** When the lexicon was created */
-  createdAt: string;
-  /** The lexicon schema definitions as JSON */
-  definitions: string;
+export interface SocialSlicesLexiconRecord {
   /** Namespaced identifier for the lexicon */
   nsid: string;
-  /** AT-URI reference to the slice this lexicon belongs to */
-  slice: string;
+  /** The lexicon schema definitions as JSON */
+  definitions: string;
+  /** When the lexicon was created */
+  createdAt: string;
   /** When the lexicon was last updated */
   updatedAt?: string;
+  /** AT-URI reference to the slice this lexicon belongs to */
+  slice: string;
 }
 
-export interface XyzSliceatSliceRecord {
+export interface SocialSlicesSliceRecord {
+  /** Name of the slice */
+  name: string;
   /** When the slice was created */
   createdAt: string;
-  /** Name of the slice */
-  name: string;
 }
 
 export class PKCEUtils {
···
   }
 }
 
-class LexiconSliceatXyzClient extends BaseClient {
+class LexiconSlicesSocialClient extends BaseClient {
   constructor(
     baseUrl: string,
     authBaseUrl: string,
···
 
   async listRecords(
     params?: ListRecordsParams
-  ): Promise<ListRecordsResponse<XyzSliceatLexiconRecord>> {
-    return await this.makeRequest("xyz.sliceat.lexicon.list", "GET", params);
+  ): Promise<ListRecordsResponse<SocialSlicesLexiconRecord>> {
+    return await this.makeRequest("social.slices.lexicon.list", "GET", params);
   }
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<XyzSliceatLexiconRecord>> {
-    return await this.makeRequest("xyz.sliceat.lexicon.get", "GET", params);
+  ): Promise<RecordResponse<SocialSlicesLexiconRecord>> {
+    return await this.makeRequest("social.slices.lexicon.get", "GET", params);
   }
 
   async createRecord(
-    record: XyzSliceatLexiconRecord
+    record: SocialSlicesLexiconRecord
   ): Promise<{ uri: string; cid: string }> {
-    const recordWithType = { $type: "xyz.sliceat.lexicon", ...record };
+    const recordWithType = { $type: "social.slices.lexicon", ...record };
     return await this.makeRequest(
-      "xyz.sliceat.lexicon.create",
+      "social.slices.lexicon.create",
       "POST",
       recordWithType
     );
···
 
   async updateRecord(
     rkey: string,
-    record: XyzSliceatLexiconRecord
+    record: SocialSlicesLexiconRecord
   ): Promise<{ uri: string; cid: string }> {
-    const recordWithType = { $type: "xyz.sliceat.lexicon", ...record };
-    return await this.makeRequest("xyz.sliceat.lexicon.update", "POST", {
+    const recordWithType = { $type: "social.slices.lexicon", ...record };
+    return await this.makeRequest("social.slices.lexicon.update", "POST", {
       rkey,
       record: recordWithType,
     });
   }
 
   async deleteRecord(rkey: string): Promise<void> {
-    return await this.makeRequest("xyz.sliceat.lexicon.delete", "POST", {
+    return await this.makeRequest("social.slices.lexicon.delete", "POST", {
       rkey,
     });
   }
 }
 
-class SliceSliceatXyzClient extends BaseClient {
+class SliceSlicesSocialClient extends BaseClient {
   constructor(
     baseUrl: string,
     authBaseUrl: string,
···
 
   async listRecords(
     params?: ListRecordsParams
-  ): Promise<ListRecordsResponse<XyzSliceatSliceRecord>> {
-    return await this.makeRequest("xyz.sliceat.slice.list", "GET", params);
+  ): Promise<ListRecordsResponse<SocialSlicesSliceRecord>> {
+    return await this.makeRequest("social.slices.slice.list", "GET", params);
   }
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<XyzSliceatSliceRecord>> {
-    return await this.makeRequest("xyz.sliceat.slice.get", "GET", params);
+  ): Promise<RecordResponse<SocialSlicesSliceRecord>> {
+    return await this.makeRequest("social.slices.slice.get", "GET", params);
   }
 
   async createRecord(
-    record: XyzSliceatSliceRecord
+    record: SocialSlicesSliceRecord
   ): Promise<{ uri: string; cid: string }> {
-    const recordWithType = { $type: "xyz.sliceat.slice", ...record };
+    const recordWithType = { $type: "social.slices.slice", ...record };
     return await this.makeRequest(
-      "xyz.sliceat.slice.create",
+      "social.slices.slice.create",
       "POST",
       recordWithType
     );
···
 
   async updateRecord(
     rkey: string,
-    record: XyzSliceatSliceRecord
+    record: SocialSlicesSliceRecord
   ): Promise<{ uri: string; cid: string }> {
-    const recordWithType = { $type: "xyz.sliceat.slice", ...record };
-    return await this.makeRequest("xyz.sliceat.slice.update", "POST", {
+    const recordWithType = { $type: "social.slices.slice", ...record };
+    return await this.makeRequest("social.slices.slice.update", "POST", {
       rkey,
       record: recordWithType,
     });
   }
 
   async deleteRecord(rkey: string): Promise<void> {
-    return await this.makeRequest("xyz.sliceat.slice.delete", "POST", { rkey });
+    return await this.makeRequest("social.slices.slice.delete", "POST", {
+      rkey,
+    });
   }
 }
 
-class SliceatXyzClient extends BaseClient {
-  readonly lexicon: LexiconSliceatXyzClient;
-  readonly slice: SliceSliceatXyzClient;
+class SlicesSocialClient extends BaseClient {
+  readonly lexicon: LexiconSlicesSocialClient;
+  readonly slice: SliceSlicesSocialClient;
 
   constructor(
     baseUrl: string,
···
     clientSecret: string
   ) {
     super(baseUrl, authBaseUrl, clientId, clientSecret);
-    this.lexicon = new LexiconSliceatXyzClient(
+    this.lexicon = new LexiconSlicesSocialClient(
       baseUrl,
       authBaseUrl,
       clientId,
       clientSecret
     );
-    this.slice = new SliceSliceatXyzClient(
+    this.slice = new SliceSlicesSocialClient(
       baseUrl,
       authBaseUrl,
       clientId,
···
   }
 }
 
-class XyzClient extends BaseClient {
-  readonly sliceat: SliceatXyzClient;
+class SocialClient extends BaseClient {
+  readonly slices: SlicesSocialClient;
 
   constructor(
     baseUrl: string,
···
     clientSecret: string
   ) {
     super(baseUrl, authBaseUrl, clientId, clientSecret);
-    this.sliceat = new SliceatXyzClient(
+    this.slices = new SlicesSocialClient(
       baseUrl,
       authBaseUrl,
       clientId,
···
 }
 
 export class AtProtoClient extends BaseClient {
-  readonly xyz: XyzClient;
+  readonly social: SocialClient;
   readonly oauth: OAuthClient;
 
   constructor(
···
     clientSecret: string
   ) {
     super(baseUrl, authBaseUrl, clientId, clientSecret);
-    this.xyz = new XyzClient(baseUrl, authBaseUrl, clientId, clientSecret);
+    this.social = new SocialClient(
+      baseUrl,
+      authBaseUrl,
+      clientId,
+      clientSecret
+    );
     this.oauth = new OAuthClient(baseUrl, authBaseUrl, clientId, clientSecret);
   }
 }

frontend/src/pages/SliceLexiconPage.tsx

···
       <div className="max-w-4xl mx-auto">
         <div className="flex items-center justify-between mb-8">
           <div className="flex items-center">
-            <a
-              href="/"
-              className="text-blue-600 hover:text-blue-800 mr-4"
-            >
+            <a href="/" className="text-blue-600 hover:text-blue-800 mr-4">
               ← Back to Slices
             </a>
-            <h1 className="text-3xl font-bold text-gray-800">
-              {sliceName}
-            </h1>
+            <h1 className="text-3xl font-bold text-gray-800">{sliceName}</h1>
           </div>
         </div>
 
···
                 className="block w-full border border-gray-300 rounded-md px-3 py-2 font-mono text-sm"
                 placeholder={`{
   "lexicon": 1,
-  "id": "xyz.sliceat.example",
+  "id": "social.slices.example",
   "description": "Example record type",
   "defs": {
     "main": {
···
               Add Lexicon
             </button>
           </form>
-          
+
           <div id="lexicon-result" className="mt-4"></div>
         </div>
 
···
             Upload Lexicon Files
           </h2>
           <p className="text-gray-600 mb-6">
-            Or upload lexicon schema files to define custom record types for this slice.
+            Or upload lexicon schema files to define custom record types for
+            this slice.
           </p>
 
           <form
···
                 className="block w-full border border-gray-300 rounded-md px-3 py-2"
               />
               <p className="text-sm text-gray-500 mt-1">
-                Upload a ZIP file containing lexicon definitions or a single JSON file
+                Upload a ZIP file containing lexicon definitions or a single
+                JSON file
               </p>
             </div>
 
···
               Slice Lexicons
             </h2>
           </div>
-          <div 
-            id="lexicon-list" 
+          <div
+            id="lexicon-list"
             className="p-6"
             hx-get="/api/lexicons/list"
             hx-trigger="load"
···
       </div>
     </Layout>
   );
-}
+}

frontend/src/routes/pages.tsx

···
 import { SliceLexiconPage } from "../pages/SliceLexiconPage.tsx";
 import { SliceCodegenPage } from "../pages/SliceCodegenPage.tsx";
 import { SliceSettingsPage } from "../pages/SliceSettingsPage.tsx";
+import { buildAtUri } from "../utils/at-uri.ts";
 
 async function handleIndexPage(req: Request): Promise<Response> {
   const context = await withAuth(req);
···
 
   if (context.currentUser.isAuthenticated) {
     try {
-      const sliceRecords = await atprotoClient.xyz.sliceat.slice.listRecords();
+      const sliceRecords =
+        await atprotoClient.social.slices.slice.listRecords();
 
       slices = sliceRecords.records.map((record) => {
         // Extract slice ID from URI
···
       // Construct the full URI for this slice
       const sliceUri = `at://${
         context.currentUser.sub || "unknown"
-      }/xyz.sliceat.slice/${sliceId}`;
+      }/social.slices.slice/${sliceId}`;
 
-      const sliceRecord = await atprotoClient.xyz.sliceat.slice.getRecord({
+      const sliceRecord = await atprotoClient.social.slices.slice.getRecord({
         uri: sliceUri,
       });
 
···
         sliceId,
         sliceName: sliceRecord.value.name,
         totalRecords: 1, // For now, just showing this slice
-        collections: [{ name: "xyz.sliceat.slice", count: 1 }],
+        collections: [{ name: "social.slices.slice", count: 1 }],
       };
-    } catch (error) {
+    } catch (_error) {
       // Fall back to default data
     }
   }
···
   if (context.currentUser.isAuthenticated) {
     try {
       // Construct the full URI for this slice
-      const sliceUri = `at://${
-        context.currentUser.sub || "unknown"
-      }/xyz.sliceat.slice/${sliceId}`;
+      const sliceUri = buildAtUri({
+        did: context.currentUser.sub ?? "unknown",
+        collection: "social.slices.slice",
+        rkey: sliceId,
+      });
 
-      const sliceRecord = await atprotoClient.xyz.sliceat.slice.getRecord({
+      const sliceRecord = await atprotoClient.social.slices.slice.getRecord({
         uri: sliceUri,
       });
 
···
         sliceId,
         sliceName: sliceRecord.value.name,
         totalRecords: 1, // For now, just showing this slice
-        collections: [{ name: "xyz.sliceat.slice", count: 1 }],
+        collections: [{ name: "social.slices.slice", count: 1 }],
       };
     } catch (error) {
       console.error("Failed to fetch slice:", error);

frontend/src/routes/slices.tsx

···
 
     // Create actual slice using AT Protocol
     try {
-      const result = await atprotoClient.xyz.sliceat.slice.createRecord({
+      const result = await atprotoClient.social.slices.slice.createRecord({
         name: name.trim(),
         createdAt: new Date().toISOString(),
       });
 
-      // Extract record key from URI (format: at://did:plc:example/xyz.sliceat.slice/rkey)
+      // Extract record key from URI (format: at://did:plc:example/social.slices.slice/rkey)
       const uriParts = result.uri.split("/");
       const sliceId = uriParts[uriParts.length - 1];
 
···
     }
 
     // Construct the URI for this slice
-    const sliceUri = `at://${context.currentUser.sub}/xyz.sliceat.slice/${sliceId}`;
+    const sliceUri = `at://${context.currentUser.sub}/social.slices.slice/${sliceId}`;
 
     // Get the current record first
-    const currentRecord = await atprotoClient.xyz.sliceat.slice.getRecord({
+    const currentRecord = await atprotoClient.social.slices.slice.getRecord({
       uri: sliceUri,
     });
 
···
       name: name.trim(),
     };
 
-    await atprotoClient.xyz.sliceat.slice.updateRecord(sliceId, updatedRecord);
+    await atprotoClient.social.slices.slice.updateRecord(
+      sliceId,
+      updatedRecord
+    );
 
     const resultHtml = render(
       <UpdateResult
···
   }
 }
 
-async function handleDeleteSlice(req: Request, params?: URLPatternResult): Promise<Response> {
+async function handleDeleteSlice(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
   const context = await withAuth(req);
   const authResponse = requireAuth(context, req);
   if (authResponse) return authResponse;
···
 
   try {
     // Delete the slice record from AT Protocol
-    await atprotoClient.xyz.sliceat.slice.deleteRecord(sliceId);
+    await atprotoClient.social.slices.slice.deleteRecord(sliceId);
 
     // Redirect to home page
     return new Response("", {
···
   try {
     // Fetch lexicons from AT Protocol
     const lexiconRecords =
-      await atprotoClient.xyz.sliceat.lexicon.listRecords();
+      await atprotoClient.social.slices.lexicon.listRecords();
 
     if (lexiconRecords.records.length === 0) {
       const html = render(<EmptyLexiconState />);
···
     // Create the lexicon record
     try {
       // For now, we'll create a simple slice reference - this could be improved to reference a specific slice
-      const sliceUri = `at://${context.currentUser.sub}/xyz.sliceat.slice/example`;
+      const sliceUri = `at://${context.currentUser.sub}/social.slices.slice/example`;
 
       const lexiconRecord = {
         nsid: lexiconData.id,
···
         slice: sliceUri,
       };
 
-      const result = await atprotoClient.xyz.sliceat.lexicon.createRecord(
+      const result = await atprotoClient.social.slices.lexicon.createRecord(
         lexiconRecord
       );
 
···
 
   try {
     // Delete the lexicon record from AT Protocol
-    await atprotoClient.xyz.sliceat.lexicon.deleteRecord(rkey);
+    await atprotoClient.social.slices.lexicon.deleteRecord(rkey);
 
     // Check if there are any remaining lexicons
     const remainingLexicons =
-      await atprotoClient.xyz.sliceat.lexicon.listRecords();
+      await atprotoClient.social.slices.lexicon.listRecords();
 
     if (remainingLexicons.records.length === 0) {
       // If no lexicons remain, return the empty state and target the parent list