social.slices -> network.slices

api/.spectral.yaml

···
 # Spectral linting for OpenAPI specs
-# 
+#
 # Usage:
 #   spectral lint <path-to-openapi-spec>
 #   spectral lint openapi.json --ruleset .spectral.yaml
 #
 # To lint the generated OpenAPI spec from the API:
-#   curl "http://localhost:3000/xrpc/social.slices.slice.openapi?slice=at://did:plc:example/social.slices.slice/example" | spectral lint -
+#   curl "http://localhost:3000/xrpc/network.slices.openapi?slice=at://did:plc:example/network.slices.slice/example" | spectral lint -
 #
 extends: ["spectral:oas"]

api/.sqlx/query-112e2cbb7ee10d0ec1261e8beebda6c126bf23dea5a8f3fe9f7e9952807a478f.json

···
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            SELECT DISTINCT json->>'nsid' as collection_nsid\n            FROM record\n            WHERE collection = 'network.slices.lexicon'\n                AND json->>'slice' = $1\n                AND json->>'nsid' IS NOT NULL\n                AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            ORDER BY json->>'nsid'\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "collection_nsid",
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "112e2cbb7ee10d0ec1261e8beebda6c126bf23dea5a8f3fe9f7e9952807a478f"
+}

api/.sqlx/query-4895a6217c253c74fae4332b31dabe04d0840ee1966d6fdb4c3dee6d2c87ad1b.json

···
-{
-  "db_name": "PostgreSQL",
-  "query": "\n            SELECT COUNT(*) as count\n            FROM record\n            WHERE collection = 'social.slices.lexicon'\n                AND json->>'slice' = $1\n                AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "count",
-        "type_info": "Int8"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text"
-      ]
-    },
-    "nullable": [
-      null
-    ]
-  },
-  "hash": "4895a6217c253c74fae4332b31dabe04d0840ee1966d6fdb4c3dee6d2c87ad1b"
-}

api/.sqlx/query-5fb1c2c7b29bfd9614e24fd391e52ca09f805ecdee4b28a4891bc527ab0d915a.json

···
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            WITH slice_collections AS (\n                SELECT DISTINCT\n                    json->>'nsid' as collection_nsid\n                FROM record\n                WHERE collection = 'network.slices.lexicon'\n                    AND json->>'slice' = $1\n                    AND json->>'nsid' IS NOT NULL\n                    AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            )\n            SELECT\n                r.collection,\n                COUNT(*) as record_count,\n                COUNT(DISTINCT r.did) as unique_actors\n            FROM record r\n            INNER JOIN slice_collections sc ON r.collection = sc.collection_nsid\n            WHERE r.slice_uri = $1\n            GROUP BY r.collection\n            ORDER BY r.collection\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "collection",
+        "type_info": "Text"
+      },
+      {
+        "ordinal": 1,
+        "name": "record_count",
+        "type_info": "Int8"
+      },
+      {
+        "ordinal": 2,
+        "name": "unique_actors",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      false,
+      null,
+      null
+    ]
+  },
+  "hash": "5fb1c2c7b29bfd9614e24fd391e52ca09f805ecdee4b28a4891bc527ab0d915a"
+}

api/.sqlx/query-6fa4f18b67c4dc5b175f353c6c03c8a77e42c5013e3deb5ce32afdcba0d150ab.json

···
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            SELECT COUNT(*) as count\n            FROM record\n            WHERE collection = 'network.slices.lexicon'\n                AND json->>'slice' = $1\n                AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "6fa4f18b67c4dc5b175f353c6c03c8a77e42c5013e3deb5ce32afdcba0d150ab"
+}

api/.sqlx/query-88080d24df604cfdcd827c8201a37414cf6ebedc5e021f67d684806bcb6b1146.json

···
-{
-  "db_name": "PostgreSQL",
-  "query": "\n            WITH slice_collections AS (\n                SELECT DISTINCT\n                    json->>'nsid' as collection_nsid\n                FROM record\n                WHERE collection = 'social.slices.lexicon'\n                    AND json->>'slice' = $1\n                    AND json->>'nsid' IS NOT NULL\n                    AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            )\n            SELECT COUNT(*) as count\n            FROM record r\n            INNER JOIN slice_collections sc ON r.collection = sc.collection_nsid\n            WHERE r.slice_uri = $1\n            ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "count",
-        "type_info": "Int8"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text"
-      ]
-    },
-    "nullable": [
-      null
-    ]
-  },
-  "hash": "88080d24df604cfdcd827c8201a37414cf6ebedc5e021f67d684806bcb6b1146"
-}

api/.sqlx/query-940380fe9b34d64b3d700032ab87b9f0e31ecd04a40e033aee2be995b3c54b28.json

···
-{
-  "db_name": "PostgreSQL",
-  "query": "\n            WITH slice_collections AS (\n                SELECT DISTINCT\n                    json->>'nsid' as collection_nsid\n                FROM record\n                WHERE collection = 'social.slices.lexicon'\n                    AND json->>'slice' = $1\n                    AND json->>'nsid' IS NOT NULL\n                    AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            )\n            SELECT\n                r.collection,\n                COUNT(*) as record_count,\n                COUNT(DISTINCT r.did) as unique_actors\n            FROM record r\n            INNER JOIN slice_collections sc ON r.collection = sc.collection_nsid\n            WHERE r.slice_uri = $1\n            GROUP BY r.collection\n            ORDER BY r.collection\n            ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "collection",
-        "type_info": "Text"
-      },
-      {
-        "ordinal": 1,
-        "name": "record_count",
-        "type_info": "Int8"
-      },
-      {
-        "ordinal": 2,
-        "name": "unique_actors",
-        "type_info": "Int8"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text"
-      ]
-    },
-    "nullable": [
-      false,
-      null,
-      null
-    ]
-  },
-  "hash": "940380fe9b34d64b3d700032ab87b9f0e31ecd04a40e033aee2be995b3c54b28"
-}

api/.sqlx/query-e583ef70eb5262bb062a4e1bab103e99fd2757e4086aef695098861151a9fb75.json

···
-{
-  "db_name": "PostgreSQL",
-  "query": "\n            SELECT DISTINCT json->>'nsid' as collection_nsid\n            FROM record\n            WHERE collection = 'social.slices.lexicon'\n                AND json->>'slice' = $1\n                AND json->>'nsid' IS NOT NULL\n                AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            ORDER BY json->>'nsid'\n            ",
-  "describe": {
-    "columns": [
-      {
-        "ordinal": 0,
-        "name": "collection_nsid",
-        "type_info": "Text"
-      }
-    ],
-    "parameters": {
-      "Left": [
-        "Text"
-      ]
-    },
-    "nullable": [
-      null
-    ]
-  },
-  "hash": "e583ef70eb5262bb062a4e1bab103e99fd2757e4086aef695098861151a9fb75"
-}

api/.sqlx/query-e62f397eb38f35e17988429c36de83f0e299c7def29dd1452706563ee58f9e3f.json

···
+{
+  "db_name": "PostgreSQL",
+  "query": "\n            WITH slice_collections AS (\n                SELECT DISTINCT\n                    json->>'nsid' as collection_nsid\n                FROM record\n                WHERE collection = 'network.slices.lexicon'\n                    AND json->>'slice' = $1\n                    AND json->>'nsid' IS NOT NULL\n                    AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'\n            )\n            SELECT COUNT(*) as count\n            FROM record r\n            INNER JOIN slice_collections sc ON r.collection = sc.collection_nsid\n            WHERE r.slice_uri = $1\n            ",
+  "describe": {
+    "columns": [
+      {
+        "ordinal": 0,
+        "name": "count",
+        "type_info": "Int8"
+      }
+    ],
+    "parameters": {
+      "Left": [
+        "Text"
+      ]
+    },
+    "nullable": [
+      null
+    ]
+  },
+  "hash": "e62f397eb38f35e17988429c36de83f0e299c7def29dd1452706563ee58f9e3f"
+}

api/.sqlx/query-fd7e15432f1c5e2b04ab38b6828bc3862e6e2b4e6d3b45a3e5aef024e815c358.json api/.sqlx/query-732081a59997cde317e535cf85e281f4502e4af3a4704a84a615a5044f48f169.json

···
 {
   "db_name": "PostgreSQL",
-  "query": "\n            SELECT json->>'domain' as domain\n            FROM record\n            WHERE collection = 'social.slices.slice'\n            AND uri = $1\n            ",
+  "query": "\n            SELECT json->>'domain' as domain\n            FROM record\n            WHERE collection = 'network.slices.slice'\n            AND uri = $1\n            ",
   "describe": {
     "columns": [
       {
···
       null
     ]
   },
-  "hash": "fd7e15432f1c5e2b04ab38b6828bc3862e6e2b4e6d3b45a3e5aef024e815c358"
+  "hash": "732081a59997cde317e535cf85e281f4502e4af3a4704a84a615a5044f48f169"
 }

api/scripts/generate_typescript.ts

···
 const lexiconsInput = Deno.args[0] || "";
 const sliceUri =
   Deno.args[1] ||
-  "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lx5zq4t56s2q";
+  "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z";
 
 if (!lexiconsInput) {
   console.error("No lexicon data provided");
···
 
 // Generate usage example based on available lexicons
 function generateUsageExample(): string {
-  // Find the first non-social.slices lexicon that has a record type
+  // Find the first non-network.slices lexicon that has a record type
   const nonSlicesLexicon = lexicons.find(
     (lex) =>
       lex.id &&
-      !lex.id.startsWith("social.slices.") &&
+      !lex.id.startsWith("network.slices.") &&
       lex.definitions &&
       Object.values(lex.definitions).some((def) => def.type === "record")
   );
···
  * });
  *
  * // Use slice-level methods for cross-collection queries with type safety
- * const sliceRecords = await client.social.slices.slice.getSliceRecords<${nsidToPascalCase(nonSlicesLexicon.id)}>({
+ * const sliceRecords = await client.network.slices.slice.getSliceRecords<${nsidToPascalCase(
+   nonSlicesLexicon.id
+ )}>({
  *   where: {
  *     collection: { eq: '${nonSlicesLexicon.id}' }
  *   }
  * });
  *
  * // Search across multiple collections using union types
- * const multiCollectionRecords = await client.social.slices.slice.getSliceRecords<${nsidToPascalCase(nonSlicesLexicon.id)} | AppBskyActorProfile>({
+ * const multiCollectionRecords = await client.network.slices.slice.getSliceRecords<${nsidToPascalCase(
+   nonSlicesLexicon.id
+ )} | AppBskyActorProfile>({
  *   where: {
  *     collection: { in: ['${nonSlicesLexicon.id}', 'app.bsky.actor.profile'] },
  *     text: { contains: 'example search term' },
···
  * \`\`\`
  */`;
   } else {
-    // Fallback: find any lexicon with a record type (including social.slices)
+    // Fallback: find any lexicon with a record type (including network.slices)
     const anyRecordLexicon = lexicons.find(
       (lex) =>
         lex.definitions &&
···
  * });
  *
  * // Cross-collection operations using base client with type safety
- * const multiCollectionResults = await client.getSliceRecords<${nsidToPascalCase(anyRecordLexicon.id)}>({
+ * const multiCollectionResults = await client.getSliceRecords<${nsidToPascalCase(
+   anyRecordLexicon.id
+ )}>({
  *   where: {
  *     collection: { eq: '${anyRecordLexicon.id}' }
  *   },
···
   sourceFile.addInterface({
     name: "GetJobLogsResponse",
     isExported: true,
-    properties: [
-      { name: "logs", type: "LogEntry[]" },
-    ],
+    properties: [{ name: "logs", type: "LogEntry[]" }],
   });
 
   sourceFile.addInterface({
     name: "GetJetstreamLogsParams",
     isExported: true,
-    properties: [
-      { name: "limit", type: "number", hasQuestionToken: true },
-    ],
+    properties: [{ name: "limit", type: "number", hasQuestionToken: true }],
   });
 
   sourceFile.addInterface({
     name: "GetJetstreamLogsResponse",
     isExported: true,
-    properties: [
-      { name: "logs", type: "LogEntry[]" },
-    ],
+    properties: [{ name: "logs", type: "LogEntry[]" }],
   });
 
   sourceFile.addInterface({
···
       { name: "sliceUri", type: "string", hasQuestionToken: true },
       { name: "level", type: "string" },
       { name: "message", type: "string" },
-      { name: "metadata", type: "Record<string, unknown>", hasQuestionToken: true },
+      {
+        name: "metadata",
+        type: "Record<string, unknown>",
+        hasQuestionToken: true,
+      },
     ],
   });
 
···
     isExported: true,
     type: "{ [K in T]?: WhereCondition }",
   });
-
 
   // IndexedRecord fields that are always available for filtering
   sourceFile.addTypeAlias({
···
   sourceFile.addInterface({
     name: "ListOAuthClientsResponse",
     isExported: true,
-    properties: [
-      { name: "clients", type: "OAuthClientDetails[]" },
-    ],
+    properties: [{ name: "clients", type: "OAuthClientDetails[]" }],
   });
 
   sourceFile.addInterface({
···
         }
       }
 
-      // Add codegen method to the social.slices.slice class
+      // Add codegen method to the network.slices.slice class
       if (
         currentPath.length === 3 &&
-        currentPath[0] === "social" &&
+        currentPath[0] === "network" &&
         currentPath[1] === "slices" &&
         currentPath[2] === "slice"
       ) {
···
           returnType: "Promise<CodegenXrpcResponse>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<CodegenXrpcResponse>('social.slices.slice.codegen', 'POST', request);`,
+            `return await this.makeRequest<CodegenXrpcResponse>('network.slices.slice.codegen', 'POST', request);`,
           ],
         });
 
···
           returnType: "Promise<SliceStatsOutput>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<SliceStatsOutput>('social.slices.slice.stats', 'POST', params);`,
+            `return await this.makeRequest<SliceStatsOutput>('network.slices.slice.stats', 'POST', params);`,
           ],
         });
 
···
           name: "getSliceRecords",
           typeParameters: [{ name: "T", default: "Record<string, unknown>" }],
           parameters: [
-            { name: "params", type: "Omit<SliceLevelRecordsParams<T>, 'slice'>" },
+            {
+              name: "params",
+              type: "Omit<SliceLevelRecordsParams<T>, 'slice'>",
+            },
           ],
           returnType: "Promise<SliceRecordsOutput<T>>",
           isAsync: true,
···
             `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
             `  slice: this.sliceUri`,
             `};`,
-            `return await this.makeRequest<SliceRecordsOutput<T>>('social.slices.slice.getSliceRecords', 'POST', requestParams);`,
+            `return await this.makeRequest<SliceRecordsOutput<T>>('network.slices.slice.getSliceRecords', 'POST', requestParams);`,
           ],
         });
 
···
           isAsync: true,
           statements: [
             `const requestParams = { ...params, slice: this.sliceUri };`,
-            `return await this.makeRequest<GetActorsResponse>('social.slices.slice.getActors', 'POST', requestParams);`,
+            `return await this.makeRequest<GetActorsResponse>('network.slices.slice.getActors', 'POST', requestParams);`,
           ],
         });
       }
 
-      // Add sync methods to the social.slices.slice class
+      // Add sync methods to the network.slices.slice class
       if (
         currentPath.length === 3 &&
-        currentPath[0] === "social" &&
+        currentPath[0] === "network" &&
         currentPath[1] === "slices" &&
         currentPath[2] === "slice"
       ) {
···
           isAsync: true,
           statements: [
             `const requestParams = { ...params, slice: this.sliceUri };`,
-            `return await this.makeRequest<SyncJobResponse>('social.slices.slice.startSync', 'POST', requestParams);`,
+            `return await this.makeRequest<SyncJobResponse>('network.slices.slice.startSync', 'POST', requestParams);`,
           ],
         });
 
···
           returnType: "Promise<JobStatus>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<JobStatus>('social.slices.slice.getJobStatus', 'GET', params);`,
+            `return await this.makeRequest<JobStatus>('network.slices.slice.getJobStatus', 'GET', params);`,
           ],
         });
 
···
           returnType: "Promise<GetJobHistoryResponse>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<GetJobHistoryResponse>('social.slices.slice.getJobHistory', 'GET', params);`,
+            `return await this.makeRequest<GetJobHistoryResponse>('network.slices.slice.getJobHistory', 'GET', params);`,
           ],
         });
 
···
           returnType: "Promise<GetJobLogsResponse>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<GetJobLogsResponse>('social.slices.slice.getJobLogs', 'GET', params);`,
+            `return await this.makeRequest<GetJobLogsResponse>('network.slices.slice.getJobLogs', 'GET', params);`,
           ],
         });
 
···
           returnType: "Promise<JetstreamStatusResponse>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<JetstreamStatusResponse>('social.slices.slice.getJetstreamStatus', 'GET');`,
+            `return await this.makeRequest<JetstreamStatusResponse>('network.slices.slice.getJetstreamStatus', 'GET');`,
           ],
         });
 
···
           returnType: "Promise<GetJetstreamLogsResponse>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<GetJetstreamLogsResponse>('social.slices.slice.getJetstreamLogs', 'GET', params);`,
+            `return await this.makeRequest<GetJetstreamLogsResponse>('network.slices.slice.getJetstreamLogs', 'GET', params);`,
           ],
         });
 
···
           isAsync: true,
           statements: [
             `const requestParams = { slice: this.sliceUri, ...params };`,
-            `return await this.makeRequest<SyncUserCollectionsResult>('social.slices.slice.syncUserCollections', 'POST', requestParams);`,
+            `return await this.makeRequest<SyncUserCollectionsResult>('network.slices.slice.syncUserCollections', 'POST', requestParams);`,
           ],
         });
 
···
           isAsync: true,
           statements: [
             `const requestParams = { ...params, sliceUri: this.sliceUri };`,
-            `return await this.makeRequest<OAuthClientDetails>('social.slices.slice.createOAuthClient', 'POST', requestParams);`,
+            `return await this.makeRequest<OAuthClientDetails>('network.slices.slice.createOAuthClient', 'POST', requestParams);`,
           ],
         });
 
···
           isAsync: true,
           statements: [
             `const requestParams = { slice: this.sliceUri };`,
-            `return await this.makeRequest<ListOAuthClientsResponse>('social.slices.slice.getOAuthClients', 'GET', requestParams);`,
+            `return await this.makeRequest<ListOAuthClientsResponse>('network.slices.slice.getOAuthClients', 'GET', requestParams);`,
           ],
         });
 
···
           isAsync: true,
           statements: [
             `const requestParams = { ...params, sliceUri: this.sliceUri };`,
-            `return await this.makeRequest<OAuthClientDetails>('social.slices.slice.updateOAuthClient', 'POST', requestParams);`,
+            `return await this.makeRequest<OAuthClientDetails>('network.slices.slice.updateOAuthClient', 'POST', requestParams);`,
           ],
         });
 
···
           returnType: "Promise<DeleteOAuthClientResponse>",
           isAsync: true,
           statements: [
-            `return await this.makeRequest<DeleteOAuthClientResponse>('social.slices.slice.deleteOAuthClient', 'POST', { clientId });`,
+            `return await this.makeRequest<DeleteOAuthClientResponse>('network.slices.slice.deleteOAuthClient', 'POST', { clientId });`,
           ],
         });
       }
···
           isAsync: true,
           statements: [
             `const requestParams = { ...params, slice: this.sliceUri };`,
-            `return await this.makeRequest<GetActorsResponse>('social.slices.slice.getActors', 'POST', requestParams);`,
+            `return await this.makeRequest<GetActorsResponse>('network.slices.slice.getActors', 'POST', requestParams);`,
           ],
         });
 
···
           name: "getSliceRecords",
           typeParameters: [{ name: "T", default: "Record<string, unknown>" }],
           parameters: [
-            { name: "params", type: "Omit<SliceLevelRecordsParams<T>, 'slice'>" },
+            {
+              name: "params",
+              type: "Omit<SliceLevelRecordsParams<T>, 'slice'>",
+            },
           ],
           returnType: "Promise<SliceRecordsOutput<T>>",
           isAsync: true,
···
             `  orWhere: undefined, // Remove orWhere as it's now in where.$or`,
             `  slice: this.sliceUri`,
             `};`,
-            `return await this.makeRequest<SliceRecordsOutput<T>>('social.slices.slice.getSliceRecords', 'POST', requestParams);`,
+            `return await this.makeRequest<SliceRecordsOutput<T>>('network.slices.slice.getSliceRecords', 'POST', requestParams);`,
           ],
         });
 

api/scripts/prod_sync.sh

···
 echo "🔄 Testing Production Sync Endpoint..."
 
 echo "🎯 Syncing slice collections with specific repos"
-curl -s -X POST https://slices-api.fly.dev/xrpc/social.slices.slice.startSync \
+curl -s -X POST https://slices-api.fly.dev/xrpc/network.slices.slice.startSync \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer $ACCESS_TOKEN" \
   -d '{
-    "slice": "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q",
+    "slice": "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z",
     "collections": [
-      "social.slices.slice",
-      "social.slices.lexicon",
-      "social.slices.actor.profile"
+      "network.slices.slice",
+      "network.slices.lexicon",
+      "network.slices.actor.profile"
     ],
     "externalCollections": [
       "app.bsky.actor.profile"

api/scripts/test_sync.sh

···
 echo "🔄 Testing Sync Endpoint..."
 
 echo "🎯 Syncing specific collections with specific repos"
-curl -s -X POST http://localhost:3000/xrpc/social.slices.slice.startSync \
+curl -s -X POST http://localhost:3000/xrpc/network.slices.slice.startSync \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer $TOKEN" \
   -d '{
-    "slice": "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q",
+    "slice": "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z",
     "collections": [
-      "social.slices.actor.profile",
-      "social.slices.slice",
-      "social.slices.lexicon"
+      "network.slices.actor.profile",
+      "network.slices.slice",
+      "network.slices.lexicon"
     ],
     "externalCollections": [
       "app.bsky.actor.profile"

api/src/database.rs

···
-use sqlx::PgPool;
 use base64::{Engine as _, engine::general_purpose};
+use sqlx::PgPool;
 
 use crate::errors::DatabaseError;
-use crate::models::{Actor, CollectionStats, IndexedRecord, Record, WhereCondition, WhereClause, SortField, OAuthClient};
+use crate::models::{
+    Actor, CollectionStats, IndexedRecord, OAuthClient, Record, SortField, WhereClause,
+    WhereCondition,
+};
 use std::collections::HashMap;
-
 
 // Helper function to build ORDER BY clause from sortBy array
 fn build_order_by_clause(sort_by: Option<&Vec<SortField>>) -> String {
···
                 };
 
                 // Validate field name to prevent SQL injection
-                if field.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '.') {
-                    if field == "indexed_at" || field == "uri" || field == "cid" || field == "did" || field == "collection" {
+                if field
+                    .chars()
+                    .all(|c| c.is_alphanumeric() || c == '_' || c == '.')
+                {
+                    if field == "indexed_at"
+                        || field == "uri"
+                        || field == "cid"
+                        || field == "did"
+                        || field == "collection"
+                    {
                         order_clauses.push(format!("{field} {direction}"));
                     } else {
                         // For JSON fields, handle nested paths and NULLs properly
···
             }
             if !order_clauses.is_empty() {
                 // Always add indexed_at as tie-breaker if not already included
-                let has_indexed_at = order_clauses.iter().any(|clause| clause.contains("indexed_at"));
+                let has_indexed_at = order_clauses
+                    .iter()
+                    .any(|clause| clause.contains("indexed_at"));
                 if !has_indexed_at {
                     order_clauses.push("indexed_at DESC".to_string());
                 }
···
     }
 }
 
-
-fn generate_cursor(sort_value: &str, indexed_at: chrono::DateTime<chrono::Utc>, cid: &str) -> String {
+fn generate_cursor(
+    sort_value: &str,
+    indexed_at: chrono::DateTime<chrono::Utc>,
+    cid: &str,
+) -> String {
     let cursor_content = format!("{}::{}::{}", sort_value, indexed_at.to_rfc3339(), cid);
     general_purpose::URL_SAFE_NO_PAD.encode(cursor_content)
 }
···
 // Extract the primary sort field from sortBy array for cursor generation
 fn get_primary_sort_field(sort_by: Option<&Vec<SortField>>) -> String {
     match sort_by {
-        Some(sort_fields) if !sort_fields.is_empty() => {
-            sort_fields[0].field.clone()
-        }
+        Some(sort_fields) if !sort_fields.is_empty() => sort_fields[0].field.clone(),
         _ => "indexed_at".to_string(),
     }
 }
···
         "indexed_at" => record.indexed_at.to_rfc3339(),
         field => {
             // Extract field value from JSON
-            record.json.get(field)
+            record
+                .json
+                .get(field)
                 .and_then(|v| match v {
                     serde_json::Value::String(s) if !s.is_empty() => Some(s.clone()),
                     serde_json::Value::Number(n) => Some(n.to_string()),
···
 ) -> (Vec<String>, Vec<String>) {
     let mut where_clauses = Vec::new();
     let mut or_clauses = Vec::new();
-    
+
     if let Some(clause) = where_clause {
         // Process regular AND conditions
         for (field, condition) in &clause.conditions {
             let field_clause = build_single_condition(field, condition, param_count);
             where_clauses.push(field_clause);
         }
-        
+
         // Process OR conditions
         if let Some(or_conditions) = &clause.or_conditions {
             for (field, condition) in or_conditions {
···
             }
         }
     }
-    
+
     (where_clauses, or_clauses)
 }
 
 // Helper function to bind parameters from WhereClause
 fn bind_where_parameters<'q>(
-    mut query_builder: sqlx::query::QueryAs<'q, sqlx::Postgres, Record, sqlx::postgres::PgArguments>,
-    where_clause: Option<&'q WhereClause>
+    mut query_builder: sqlx::query::QueryAs<
+        'q,
+        sqlx::Postgres,
+        Record,
+        sqlx::postgres::PgArguments,
+    >,
+    where_clause: Option<&'q WhereClause>,
 ) -> sqlx::query::QueryAs<'q, sqlx::Postgres, Record, sqlx::postgres::PgArguments> {
     if let Some(clause) = where_clause {
         // Bind AND condition parameters
         for (_, condition) in &clause.conditions {
             query_builder = bind_single_condition(query_builder, condition);
         }
-        
-        // Bind OR condition parameters  
+
+        // Bind OR condition parameters
         if let Some(or_conditions) = &clause.or_conditions {
             for (_, condition) in or_conditions {
                 query_builder = bind_single_condition(query_builder, condition);
···
 
 // Helper function to bind parameters for a single condition
 fn bind_single_condition<'q>(
-    mut query_builder: sqlx::query::QueryAs<'q, sqlx::Postgres, Record, sqlx::postgres::PgArguments>,
-    condition: &'q WhereCondition
+    mut query_builder: sqlx::query::QueryAs<
+        'q,
+        sqlx::Postgres,
+        Record,
+        sqlx::postgres::PgArguments,
+    >,
+    condition: &'q WhereCondition,
 ) -> sqlx::query::QueryAs<'q, sqlx::Postgres, Record, sqlx::postgres::PgArguments> {
     if let Some(eq_value) = &condition.eq {
         if let Some(str_val) = eq_value.as_str() {
···
             query_builder = query_builder.bind(eq_value);
         }
     }
-    
+
     if let Some(in_values) = &condition.in_values {
-        let str_values: Vec<String> = in_values.iter()
+        let str_values: Vec<String> = in_values
+            .iter()
             .filter_map(|v| v.as_str().map(|s| s.to_string()))
             .collect();
         query_builder = query_builder.bind(str_values);
     }
-    
+
     if let Some(contains_value) = &condition.contains {
         query_builder = query_builder.bind(contains_value);
     }
-    
+
     query_builder
 }
 
 // Helper function to build a single condition clause
-fn build_single_condition(field: &str, condition: &WhereCondition, param_count: &mut usize) -> String {
+fn build_single_condition(
+    field: &str,
+    condition: &WhereCondition,
+    param_count: &mut usize,
+) -> String {
     if let Some(_eq_value) = &condition.eq {
         let clause = match field {
             "did" | "collection" | "uri" | "cid" => {
···
 
         // Build bulk INSERT with multiple VALUES
         let mut query = String::from(
-            r#"INSERT INTO "record" ("uri", "cid", "did", "collection", "json", "indexed_at", "slice_uri") VALUES "#
+            r#"INSERT INTO "record" ("uri", "cid", "did", "collection", "json", "indexed_at", "slice_uri") VALUES "#,
         );
 
         // Add placeholders for each record
···
             let base = i * 7 + 1; // 7 fields per record
             query.push_str(&format!(
                 "(${}, ${}, ${}, ${}, ${}, ${}, ${})",
-                base, base + 1, base + 2, base + 3, base + 4, base + 5, base + 6
+                base,
+                base + 1,
+                base + 2,
+                base + 3,
+                base + 4,
+                base + 5,
+                base + 6
             ));
         }
 
-        query.push_str(r#"
+        query.push_str(
+            r#"
             ON CONFLICT ON CONSTRAINT record_pkey
             DO UPDATE SET
                 "cid" = EXCLUDED."cid",
                 "json" = EXCLUDED."json",
                 "indexed_at" = EXCLUDED."indexed_at"
-        "#);
+        "#,
+        );
 
         // Bind all parameters
         let mut sqlx_query = sqlx::query(&query);
···
         Ok(())
     }
 
-    pub async fn get_existing_record_cids_for_slice(&self, did: &str, collection: &str, slice_uri: &str) -> Result<std::collections::HashMap<String, String>, DatabaseError> {
+    pub async fn get_existing_record_cids_for_slice(
+        &self,
+        did: &str,
+        collection: &str,
+        slice_uri: &str,
+    ) -> Result<std::collections::HashMap<String, String>, DatabaseError> {
         let records = sqlx::query!(
             r#"SELECT "uri", "cid"
                FROM "record"
···
         Ok(indexed_record)
     }
 
-
-    pub async fn get_lexicons_by_slice(&self, slice_uri: &str) -> Result<Vec<serde_json::Value>, DatabaseError> {
+    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", "indexed_at", "slice_uri"
                FROM "record"
-               WHERE "collection" = 'social.slices.lexicon'
+               WHERE "collection" = 'network.slices.lexicon'
                AND "json"->>'slice' = $1
                ORDER BY "indexed_at" DESC"#,
         )
···
 
         Ok(lexicon_definitions)
     }
-
-
-
 
     pub async fn update_record(&self, record: &Record) -> Result<(), DatabaseError> {
         let result = sqlx::query!(
···
         .await?;
 
         if result.rows_affected() == 0 {
-            return Err(DatabaseError::RecordNotFound { uri: record.uri.clone() });
+            return Err(DatabaseError::RecordNotFound {
+                uri: record.uri.clone(),
+            });
         }
 
         Ok(())
     }
-
 
     pub async fn batch_insert_actors(&self, actors: &[Actor]) -> Result<(), DatabaseError> {
         if actors.is_empty() {
···
 
         // Process actors in chunks to avoid hitting parameter limits
         const CHUNK_SIZE: usize = 1000;
-        
+
         for chunk in actors.chunks(CHUNK_SIZE) {
             for actor in chunk {
                 sqlx::query!(
···
         Ok(())
     }
 
-    pub async fn get_slice_collection_stats(&self, slice_uri: &str) -> Result<Vec<CollectionStats>, DatabaseError> {
+    pub async fn get_slice_collection_stats(
+        &self,
+        slice_uri: &str,
+    ) -> Result<Vec<CollectionStats>, DatabaseError> {
         let stats = sqlx::query!(
             r#"
             WITH slice_collections AS (
                 SELECT DISTINCT
                     json->>'nsid' as collection_nsid
                 FROM record
-                WHERE collection = 'social.slices.lexicon'
+                WHERE collection = 'network.slices.lexicon'
                     AND json->>'slice' = $1
                     AND json->>'nsid' IS NOT NULL
                     AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'
···
         .fetch_all(&self.pool)
         .await?;
 
-        Ok(stats.into_iter().map(|row| CollectionStats {
-            collection: row.collection,
-            record_count: row.record_count.unwrap_or(0),
-            unique_actors: row.unique_actors.unwrap_or(0),
-        }).collect())
+        Ok(stats
+            .into_iter()
+            .map(|row| CollectionStats {
+                collection: row.collection,
+                record_count: row.record_count.unwrap_or(0),
+                unique_actors: row.unique_actors.unwrap_or(0),
+            })
+            .collect())
     }
 
-    pub async fn get_slice_collections_list(&self, slice_uri: &str) -> Result<Vec<String>, DatabaseError> {
+    pub async fn get_slice_collections_list(
+        &self,
+        slice_uri: &str,
+    ) -> Result<Vec<String>, DatabaseError> {
         let rows = sqlx::query!(
             r#"
             SELECT DISTINCT json->>'nsid' as collection_nsid
             FROM record
-            WHERE collection = 'social.slices.lexicon'
+            WHERE collection = 'network.slices.lexicon'
                 AND json->>'slice' = $1
                 AND json->>'nsid' IS NOT NULL
                 AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'
···
         .fetch_all(&self.pool)
         .await?;
 
-        Ok(rows.into_iter()
+        Ok(rows
+            .into_iter()
             .filter_map(|row| row.collection_nsid)
             .collect())
     }
···
                 SELECT DISTINCT
                     json->>'nsid' as collection_nsid
                 FROM record
-                WHERE collection = 'social.slices.lexicon'
+                WHERE collection = 'network.slices.lexicon'
                     AND json->>'slice' = $1
                     AND json->>'nsid' IS NOT NULL
                     AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'
···
         slice_uri: &str,
         limit: Option<i32>,
         cursor: Option<&str>,
-        where_conditions: Option<&HashMap<String, WhereCondition>>
+        where_conditions: Option<&HashMap<String, WhereCondition>>,
     ) -> Result<(Vec<Actor>, Option<String>), DatabaseError> {
         let limit = limit.unwrap_or(50).min(100); // Cap at 100
-        
+
         // Handle where conditions with specific cases
         let records = if let Some(conditions) = where_conditions {
             // Check for handle contains filter
···
                     }
                 } else {
                     // Default case with basic filtering
-                    self.query_actors_with_cursor(slice_uri, cursor, limit).await?
+                    self.query_actors_with_cursor(slice_uri, cursor, limit)
+                        .await?
                 }
             } else if let Some(did_condition) = conditions.get("did") {
                 if let Some(in_values) = &did_condition.in_values {
-                    let string_values: Vec<String> = in_values.iter()
+                    let string_values: Vec<String> = in_values
+                        .iter()
                         .filter_map(|v| v.as_str())
                         .map(|s| s.to_string())
                         .collect();
-                    
+
                     sqlx::query_as!(
                         Actor,
                         r#"
···
                     }
                 } else {
                     // Default case with basic filtering
-                    self.query_actors_with_cursor(slice_uri, cursor, limit).await?
+                    self.query_actors_with_cursor(slice_uri, cursor, limit)
+                        .await?
                 }
             } else {
                 // Default case with basic filtering
-                self.query_actors_with_cursor(slice_uri, cursor, limit).await?
+                self.query_actors_with_cursor(slice_uri, cursor, limit)
+                    .await?
             }
         } else {
             // No where conditions, just basic slice + cursor filtering
-            self.query_actors_with_cursor(slice_uri, cursor, limit).await?
+            self.query_actors_with_cursor(slice_uri, cursor, limit)
+                .await?
         };
-        
+
         // Generate cursor from the last record if there are any records
         let cursor = if records.is_empty() {
             None
···
 
         Ok((records, cursor))
     }
-    
-    async fn query_actors_with_cursor(&self, slice_uri: &str, cursor: Option<&str>, limit: i32) -> Result<Vec<Actor>, DatabaseError> {
+
+    async fn query_actors_with_cursor(
+        &self,
+        slice_uri: &str,
+        cursor: Option<&str>,
+        limit: i32,
+    ) -> Result<Vec<Actor>, DatabaseError> {
         match cursor {
-            Some(cursor_did) => {
-                sqlx::query_as!(
-                    Actor,
-                    r#"
+            Some(cursor_did) => sqlx::query_as!(
+                Actor,
+                r#"
                     SELECT did, handle, slice_uri, indexed_at
                     FROM actor
                     WHERE slice_uri = $1 AND did > $2
                     ORDER BY did ASC
                     LIMIT $3
                     "#,
-                    slice_uri,
-                    cursor_did,
-                    limit as i64
-                )
-                .fetch_all(&self.pool)
-                .await
-                .map_err(DatabaseError::from)
-            },
-            None => {
-                sqlx::query_as!(
-                    Actor,
-                    r#"
+                slice_uri,
+                cursor_did,
+                limit as i64
+            )
+            .fetch_all(&self.pool)
+            .await
+            .map_err(DatabaseError::from),
+            None => sqlx::query_as!(
+                Actor,
+                r#"
                     SELECT did, handle, slice_uri, indexed_at
                     FROM actor
                     WHERE slice_uri = $1
                     ORDER BY did ASC
                     LIMIT $2
                     "#,
-                    slice_uri,
-                    limit as i64
-                )
-                .fetch_all(&self.pool)
-                .await
-                .map_err(DatabaseError::from)
-            }
+                slice_uri,
+                limit as i64
+            )
+            .fetch_all(&self.pool)
+            .await
+            .map_err(DatabaseError::from),
         }
     }
 
···
             r#"
             SELECT COUNT(*) as count
             FROM record
-            WHERE collection = 'social.slices.lexicon'
+            WHERE collection = 'network.slices.lexicon'
                 AND json->>'slice' = $1
                 AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'
             "#,
···
         Ok(count.count.unwrap_or(0))
     }
 
-
     pub async fn get_slice_collections_records(
         &self,
         slice_uri: &str,
         limit: Option<i32>,
         cursor: Option<&str>,
         sort_by: Option<&Vec<SortField>>,
-        where_clause: Option<&WhereClause>
+        where_clause: Option<&WhereClause>,
     ) -> Result<(Vec<Record>, Option<String>), DatabaseError> {
         let limit = limit.unwrap_or(50).min(100); // Cap at 100
         let order_by = build_order_by_clause(sort_by);
···
         let mut where_clauses = Vec::new();
         let mut param_count = 1;
 
-        // Always filter by slice_uri, except for social.slices.lexicon which uses json->>'slice'
-        let is_lexicon = where_clause.as_ref()
+        // Always filter by slice_uri, except for network.slices.lexicon which uses json->>'slice'
+        let is_lexicon = where_clause
+            .as_ref()
             .and_then(|wc| wc.conditions.get("collection"))
             .and_then(|c| c.eq.as_ref())
             .and_then(|v| v.as_str())
-            .map_or(false, |s| s == "social.slices.lexicon");
-        
-        if is_lexicon
-        {
+            .map_or(false, |s| s == "network.slices.lexicon");
+
+        if is_lexicon {
             where_clauses.push(format!("json->>'slice' = ${}", param_count));
         } else {
             where_clauses.push(format!("slice_uri = ${}", param_count));
···
         }
 
         // Use helper function to build where conditions
-        let (and_conditions, or_conditions) = build_where_conditions(where_clause, &mut param_count);
+        let (and_conditions, or_conditions) =
+            build_where_conditions(where_clause, &mut param_count);
         where_clauses.extend(and_conditions);
-        
+
         // Add OR conditions with proper parentheses if present
         if !or_conditions.is_empty() {
             let or_clause = format!("({})", or_conditions.join(" OR "));
             where_clauses.push(or_clause);
         }
-
 
         // Build the final query
         let where_sql = where_clauses.join(" AND ");
···
 
         // Bind cursor if present
         if let Some(cursor_time) = cursor {
-            let cursor_dt = cursor_time.parse::<chrono::DateTime<chrono::Utc>>()
+            let cursor_dt = cursor_time
+                .parse::<chrono::DateTime<chrono::Utc>>()
                 .unwrap_or_else(|_| chrono::Utc::now());
             query_builder = query_builder.bind(cursor_dt);
         }
···
         let cursor = if records.is_empty() {
             None
         } else {
-            records.last().map(|record| generate_cursor_from_record(record, sort_by))
+            records
+                .last()
+                .map(|record| generate_cursor_from_record(record, sort_by))
         };
 
         Ok((records, cursor))
···
     pub async fn count_slice_collections_records(
         &self,
         slice_uri: &str,
-        where_clause: Option<&WhereClause>
+        where_clause: Option<&WhereClause>,
     ) -> Result<i64, DatabaseError> {
         // Build WHERE clause dynamically
         let mut where_clauses = Vec::new();
         let mut param_count = 1;
 
-        // Always filter by slice_uri, except for social.slices.lexicon which uses json->>'slice'
-        let is_lexicon = where_clause.as_ref()
+        // Always filter by slice_uri, except for network.slices.lexicon which uses json->>'slice'
+        let is_lexicon = where_clause
+            .as_ref()
             .and_then(|wc| wc.conditions.get("collection"))
             .and_then(|c| c.eq.as_ref())
             .and_then(|v| v.as_str())
-            .map_or(false, |s| s == "social.slices.lexicon");
-        
-        if is_lexicon
-        {
+            .map_or(false, |s| s == "network.slices.lexicon");
+
+        if is_lexicon {
             where_clauses.push(format!("json->>'slice' = ${}", param_count));
         } else {
             where_clauses.push(format!("slice_uri = ${}", param_count));
···
         param_count += 1;
 
         // Use helper function to build where conditions
-        let (and_conditions, or_conditions) = build_where_conditions(where_clause, &mut param_count);
+        let (and_conditions, or_conditions) =
+            build_where_conditions(where_clause, &mut param_count);
         where_clauses.extend(and_conditions);
-        
+
         // Add OR conditions with proper parentheses if present
         if !or_conditions.is_empty() {
             let or_clause = format!("({})", or_conditions.join(" OR "));
             where_clauses.push(or_clause);
         }
-
 
         // Build the final query
         let where_sql = if where_clauses.is_empty() {
···
 
         let query = format!("SELECT COUNT(*) as count FROM record{}", where_sql);
 
-        // Execute query with parameters  
+        // Execute query with parameters
         let mut query_builder = sqlx::query_scalar::<_, i64>(&query);
         query_builder = query_builder.bind(slice_uri);
 
···
                     }
                 }
                 if let Some(in_values) = &condition.in_values {
-                    let str_values: Vec<String> = in_values.iter()
+                    let str_values: Vec<String> = in_values
+                        .iter()
                         .filter_map(|v| v.as_str().map(|s| s.to_string()))
                         .collect();
                     query_builder = query_builder.bind(str_values);
···
                     query_builder = query_builder.bind(contains_value);
                 }
             }
-            
+
             // Bind OR condition parameters
             if let Some(or_conditions) = &clause.or_conditions {
                 for (_, condition) in or_conditions {
···
                         }
                     }
                     if let Some(in_values) = &condition.in_values {
-                        let str_values: Vec<String> = in_values.iter()
+                        let str_values: Vec<String> = in_values
+                            .iter()
                             .filter_map(|v| v.as_str().map(|s| s.to_string()))
                             .collect();
                         query_builder = query_builder.bind(str_values);
···
         Ok(count)
     }
 
-    pub async fn delete_record_by_uri(&self, uri: &str, slice_uri: Option<&str>) -> Result<u64, DatabaseError> {
+    pub async fn delete_record_by_uri(
+        &self,
+        uri: &str,
+        slice_uri: Option<&str>,
+    ) -> Result<u64, DatabaseError> {
         let result = if let Some(slice_uri) = slice_uri {
             sqlx::query("DELETE FROM record WHERE uri = $1 AND slice_uri = $2")
                 .bind(uri)
···
         Ok(result.rows_affected())
     }
 
-
     pub async fn upsert_record(&self, record: &Record) -> Result<bool, DatabaseError> {
         // Returns true if inserted, false if updated
-        let result = sqlx::query_scalar::<_, bool>(r#"
+        let result = sqlx::query_scalar::<_, bool>(
+            r#"
             INSERT INTO record (uri, cid, did, collection, json, indexed_at, slice_uri)
             VALUES ($1, $2, $3, $4, $5, $6, $7)
             ON CONFLICT ON CONSTRAINT record_pkey DO UPDATE
···
                 json = EXCLUDED.json,
                 indexed_at = EXCLUDED.indexed_at
             RETURNING (xmax = 0)
-        "#)
+        "#,
+        )
         .bind(&record.uri)
         .bind(&record.cid)
         .bind(&record.did)
···
     }
 
     pub async fn get_all_slices(&self) -> Result<Vec<String>, DatabaseError> {
-        let rows: Vec<(String,)> = sqlx::query_as(r#"
+        let rows: Vec<(String,)> = sqlx::query_as(
+            r#"
             SELECT DISTINCT json->>'slice' as slice_uri
             FROM record
-            WHERE collection = 'social.slices.lexicon'
+            WHERE collection = 'network.slices.lexicon'
             AND json->>'slice' IS NOT NULL
-        "#)
+        "#,
+        )
         .fetch_all(&self.pool)
         .await?;
 
         Ok(rows.into_iter().map(|(uri,)| uri).collect())
     }
-
 
     pub async fn get_all_actors(&self) -> Result<Vec<(String, String)>, DatabaseError> {
         let rows = sqlx::query!(
···
         .fetch_all(&self.pool)
         .await?;
 
-        Ok(rows.into_iter().map(|row| (row.did, row.slice_uri)).collect())
+        Ok(rows
+            .into_iter()
+            .map(|row| (row.did, row.slice_uri))
+            .collect())
     }
 
     pub async fn get_slice_domain(&self, slice_uri: &str) -> Result<Option<String>, DatabaseError> {
···
             r#"
             SELECT json->>'domain' as domain
             FROM record
-            WHERE collection = 'social.slices.slice'
+            WHERE collection = 'network.slices.slice'
             AND uri = $1
             "#,
             slice_uri
···
         Ok(client)
     }
 
-    pub async fn get_oauth_clients_for_slice(&self, slice_uri: &str) -> Result<Vec<OAuthClient>, DatabaseError> {
+    pub async fn get_oauth_clients_for_slice(
+        &self,
+        slice_uri: &str,
+    ) -> Result<Vec<OAuthClient>, DatabaseError> {
         let clients = sqlx::query_as!(
             OAuthClient,
             r#"
···
         Ok(clients)
     }
 
-    pub async fn get_oauth_client_by_id(&self, client_id: &str) -> Result<Option<OAuthClient>, DatabaseError> {
+    pub async fn get_oauth_client_by_id(
+        &self,
+        client_id: &str,
+    ) -> Result<Option<OAuthClient>, DatabaseError> {
         let client = sqlx::query_as!(
             OAuthClient,
             r#"
···
         .await?;
 
         if result.rows_affected() == 0 {
-            return Err(DatabaseError::RecordNotFound { uri: client_id.to_string() });
+            return Err(DatabaseError::RecordNotFound {
+                uri: client_id.to_string(),
+            });
         }
 
         Ok(())
     }
-
 }

api/src/handler_sync_user_collections.rs

···
 use serde::Deserialize;
 use tracing::{info, warn};
 
+use crate::AppState;
 use crate::auth::{extract_bearer_token, verify_oauth_token};
 use crate::sync::{SyncService, SyncUserCollectionsResult};
-use crate::AppState;
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
···
     30 // 30 second default timeout for login scenarios
 }
 
-/// Handler for social.slices.slice.syncUserCollections
+/// Handler for network.slices.slice.syncUserCollections
 /// Synchronously syncs external collections for the authenticated user with timeout protection
 /// Automatically discovers external collections based on the slice's domain configuration
 pub async fn sync_user_collections(
···
 ) -> Result<Json<SyncUserCollectionsResult>, (StatusCode, Json<serde_json::Value>)> {
     // Extract and verify OAuth token
     let token = extract_bearer_token(&headers).map_err(|e| {
-        (StatusCode::UNAUTHORIZED, Json(serde_json::json!({
-            "error": "AuthenticationRequired",
-            "message": format!("Bearer token required: {}", e)
-        })))
+        (
+            StatusCode::UNAUTHORIZED,
+            Json(serde_json::json!({
+                "error": "AuthenticationRequired",
+                "message": format!("Bearer token required: {}", e)
+            })),
+        )
     })?;
 
-    let user_info = verify_oauth_token(&token, &state.config.auth_base_url).await
+    let user_info = verify_oauth_token(&token, &state.config.auth_base_url)
+        .await
         .map_err(|e| {
-            (StatusCode::UNAUTHORIZED, Json(serde_json::json!({
-                "error": "InvalidToken",
-                "message": format!("Token verification failed: {}", e)
-            })))
+            (
+                StatusCode::UNAUTHORIZED,
+                Json(serde_json::json!({
+                    "error": "InvalidToken",
+                    "message": format!("Token verification failed: {}", e)
+                })),
+            )
         })?;
 
     let user_did = user_info.did.unwrap_or(user_info.sub);
-    
+
     info!(
         "🔄 Starting user collections sync for {} on slice {} (timeout: {}s)",
         user_did, request.slice, request.timeout_seconds
···
 
     // Validate timeout (max 5 minutes for sync operations)
     if request.timeout_seconds > 300 {
-        return Err((StatusCode::BAD_REQUEST, Json(serde_json::json!({
-            "error": "InvalidTimeout",
-            "message": "Maximum timeout is 300 seconds (5 minutes)"
-        }))));
+        return Err((
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({
+                "error": "InvalidTimeout",
+                "message": "Maximum timeout is 300 seconds (5 minutes)"
+            })),
+        ));
     }
 
     // Create sync service
-    let sync_service = SyncService::new(state.database.clone(), state.config.relay_endpoint.clone());
-    
+    let sync_service =
+        SyncService::new(state.database.clone(), state.config.relay_endpoint.clone());
+
     // Perform timeout-protected sync with auto-discovered external collections
-    match sync_service.sync_user_collections(
-        &user_did,
-        &request.slice,
-        request.timeout_seconds,
-    ).await {
+    match sync_service
+        .sync_user_collections(&user_did, &request.slice, request.timeout_seconds)
+        .await
+    {
         Ok(result) => {
             if result.timed_out {
                 info!(
···
                 );
             }
             Ok(Json(result))
-        },
+        }
         Err(e) => {
             warn!("❌ Sync failed for user {}: {}", user_did, e);
-            Err((StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({
-                "error": "SyncFailed",
-                "message": format!("Sync operation failed: {}", e)
-            }))))
+            Err((
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(serde_json::json!({
+                    "error": "SyncFailed",
+                    "message": format!("Sync operation failed: {}", e)
+                })),
+            ))
         }
     }
-}
+}

api/src/handler_xrpc_dynamic.rs

···
+use atproto_client::com::atproto::repo::{
+    CreateRecordRequest, CreateRecordResponse, DeleteRecordRequest, PutRecordRequest,
+    PutRecordResponse, create_record, delete_record, put_record,
+};
 use axum::{
     extract::{Path, Query, State},
     http::{HeaderMap, StatusCode},
     response::Json,
 };
-use serde::Deserialize;
 use chrono::Utc;
-use atproto_client::com::atproto::repo::{CreateRecordRequest, PutRecordRequest, DeleteRecordRequest, create_record, put_record, delete_record, CreateRecordResponse, PutRecordResponse};
+use serde::Deserialize;
 
-use crate::auth::{extract_bearer_token, verify_oauth_token, get_atproto_auth_for_user};
+use crate::AppState;
+use crate::auth::{extract_bearer_token, get_atproto_auth_for_user, verify_oauth_token};
 use crate::lexicon::LexiconValidator;
-use crate::models::{Record, SliceRecordsParams, SliceRecordsOutput, IndexedRecord, WhereCondition, SortField};
+use crate::models::{
+    IndexedRecord, Record, SliceRecordsOutput, SliceRecordsParams, SortField, WhereCondition,
+};
 use std::collections::HashMap;
-use crate::AppState;
 
 // Helper function to convert StatusCode errors to JSON error responses
 fn status_to_error_response(status: StatusCode) -> (StatusCode, Json<serde_json::Value>) {
···
         _ => "Request failed",
     };
 
-    (status, Json(serde_json::json!({
-        "error": status.as_str(),
-        "message": message
-    })))
+    (
+        status,
+        Json(serde_json::json!({
+            "error": status.as_str(),
+            "message": message
+        })),
+    )
 }
-
-
 
 #[derive(Deserialize)]
 pub struct GetRecordParams {
···
     headers: HeaderMap,
     Json(body): Json<serde_json::Value>,
 ) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
-
     // Handle dynamic collection methods (e.g., social.grain.gallery.createRecord)
     if method.ends_with(".getRecords") {
         let collection = method.trim_end_matches(".getRecords").to_string();
···
     params: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
     // Parse parameters into SliceRecordsParams format
-    let slice = params.get("slice")
+    let slice = params
+        .get("slice")
         .and_then(|v| v.as_str())
         .ok_or(StatusCode::BAD_REQUEST)?
         .to_string();
···
         }
     });
 
-    let cursor = params.get("cursor")
+    let cursor = params
+        .get("cursor")
         .and_then(|v| v.as_str())
         .map(|s| s.to_string());
 
     // Parse sortBy from params - convert legacy sort string to new array format if present
-    let sort_by = params.get("sort")
-        .and_then(|v| v.as_str())
-        .map(|sort_str| {
-            // Convert legacy "field:direction" format to new array format
-            let mut sort_fields = Vec::new();
-            for sort_item in sort_str.split(',') {
-                let parts: Vec<&str> = sort_item.trim().split(':').collect();
-                if parts.len() == 2 {
-                    sort_fields.push(SortField {
-                        field: parts[0].trim().to_string(),
-                        direction: parts[1].trim().to_string(),
-                    });
-                } else if parts.len() == 1 && !parts[0].is_empty() {
-                    // Default to ascending if no direction specified
-                    sort_fields.push(SortField {
-                        field: parts[0].trim().to_string(),
-                        direction: "asc".to_string(),
-                    });
-                }
+    let sort_by = params.get("sort").and_then(|v| v.as_str()).map(|sort_str| {
+        // Convert legacy "field:direction" format to new array format
+        let mut sort_fields = Vec::new();
+        for sort_item in sort_str.split(',') {
+            let parts: Vec<&str> = sort_item.trim().split(':').collect();
+            if parts.len() == 2 {
+                sort_fields.push(SortField {
+                    field: parts[0].trim().to_string(),
+                    direction: parts[1].trim().to_string(),
+                });
+            } else if parts.len() == 1 && !parts[0].is_empty() {
+                // Default to ascending if no direction specified
+                sort_fields.push(SortField {
+                    field: parts[0].trim().to_string(),
+                    direction: "asc".to_string(),
+                });
             }
-            sort_fields
-        });
+        }
+        sort_fields
+    });
 
     // Parse where conditions from query params if present
     let mut where_conditions = HashMap::new();
 
     // Handle legacy author/authors params by converting to where clause
     if let Some(author_str) = params.get("author").and_then(|v| v.as_str()) {
-        where_conditions.insert("did".to_string(), WhereCondition {
-            eq: Some(serde_json::Value::String(author_str.to_string())),
-            in_values: None,
-            contains: None,
-        });
+        where_conditions.insert(
+            "did".to_string(),
+            WhereCondition {
+                eq: Some(serde_json::Value::String(author_str.to_string())),
+                in_values: None,
+                contains: None,
+            },
+        );
     } else if let Some(authors_str) = params.get("authors").and_then(|v| v.as_str()) {
         let authors: Vec<serde_json::Value> = authors_str
             .split(',')
             .map(|s| serde_json::Value::String(s.trim().to_string()))
             .collect();
-        where_conditions.insert("did".to_string(), WhereCondition {
-            eq: None,
-            in_values: Some(authors),
-            contains: None,
-        });
+        where_conditions.insert(
+            "did".to_string(),
+            WhereCondition {
+                eq: None,
+                in_values: Some(authors),
+                contains: None,
+            },
+        );
     }
 
     // Handle legacy query param by converting to where clause with contains
     if let Some(query_str) = params.get("query").and_then(|v| v.as_str()) {
-        let field = params.get("field")
+        let field = params
+            .get("field")
             .and_then(|v| v.as_str())
             .unwrap_or("text"); // Default to text field for search
-        where_conditions.insert(field.to_string(), WhereCondition {
-            eq: None,
-            in_values: None,
-            contains: Some(query_str.to_string()),
-        });
+        where_conditions.insert(
+            field.to_string(),
+            WhereCondition {
+                eq: None,
+                in_values: None,
+                contains: Some(query_str.to_string()),
+            },
+        );
     }
 
     let where_clause = if where_conditions.is_empty() {
···
     };
 
     // First verify the collection belongs to this slice
-    let slice_collections = state.database.get_slice_collections_list(&records_params.slice).await
+    let slice_collections = state
+        .database
+        .get_slice_collections_list(&records_params.slice)
+        .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    // Special handling: social.slices.lexicon is always allowed as it defines the schema
-    if collection != "social.slices.lexicon" && !slice_collections.contains(&collection) {
+    // Special handling: network.slices.lexicon is always allowed as it defines the schema
+    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
         return Err(StatusCode::NOT_FOUND);
     }
 
     // Use the unified database method
-    match state.database.get_slice_collections_records(
-        &records_params.slice,
-        records_params.limit,
-        records_params.cursor.as_deref(),
-        sort_by.as_ref(),
-        records_params.where_clause.as_ref(),
-    ).await {
+    match state
+        .database
+        .get_slice_collections_records(
+            &records_params.slice,
+            records_params.limit,
+            records_params.cursor.as_deref(),
+            sort_by.as_ref(),
+            records_params.where_clause.as_ref(),
+        )
+        .await
+    {
         Ok((mut records, cursor)) => {
             // Filter records to only include the specific collection
             records.retain(|record| record.collection == collection);
 
-            let indexed_records: Vec<IndexedRecord> = records.into_iter().map(|record| IndexedRecord {
-                uri: record.uri,
-                cid: record.cid,
-                did: record.did,
-                collection: record.collection,
-                value: record.json,
-                indexed_at: record.indexed_at.to_rfc3339(),
-            }).collect();
+            let indexed_records: Vec<IndexedRecord> = records
+                .into_iter()
+                .map(|record| IndexedRecord {
+                    uri: record.uri,
+                    cid: record.cid,
+                    did: record.did,
+                    collection: record.collection,
+                    value: record.json,
+                    indexed_at: record.indexed_at.to_rfc3339(),
+                })
+                .collect();
 
             let output = SliceRecordsOutput {
                 success: true,
···
                 message: None,
             };
 
-            Ok(Json(serde_json::to_value(output)
-                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?))
-        },
+            Ok(Json(
+                serde_json::to_value(output).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?,
+            ))
+        }
         Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
     }
 }
-
-
 
 // Implementation for get record
 async fn dynamic_get_record_impl(
···
     state: AppState,
     params: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
-    let get_params: GetRecordParams = serde_json::from_value(params)
-        .map_err(|_| StatusCode::BAD_REQUEST)?;
+    let get_params: GetRecordParams =
+        serde_json::from_value(params).map_err(|_| StatusCode::BAD_REQUEST)?;
 
     // First verify the collection belongs to this slice
-    let slice_collections = state.database.get_slice_collections_list(&get_params.slice).await
+    let slice_collections = state
+        .database
+        .get_slice_collections_list(&get_params.slice)
+        .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    // Special handling: social.slices.lexicon is always allowed as it defines the schema
-    if collection != "social.slices.lexicon" && !slice_collections.contains(&collection) {
+    // Special handling: network.slices.lexicon is always allowed as it defines the schema
+    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
         return Err(StatusCode::NOT_FOUND);
     }
 
     // Use direct database query by URI for efficiency
     match state.database.get_record(&get_params.uri).await {
         Ok(Some(record)) => {
-            let json_value = serde_json::to_value(record)
-                .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+            let json_value =
+                serde_json::to_value(record).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
             Ok(Json(json_value))
-        },
-        Ok(None) => {
-            Err(StatusCode::NOT_FOUND)
-        },
-        Err(_e) => {
-            Err(StatusCode::INTERNAL_SERVER_ERROR)
-        },
+        }
+        Ok(None) => Err(StatusCode::NOT_FOUND),
+        Err(_e) => Err(StatusCode::INTERNAL_SERVER_ERROR),
     }
 }
 
···
     body: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
     // Parse the JSON body into SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(body)
-        .map_err(|_| (StatusCode::BAD_REQUEST, Json(serde_json::json!({"error": "Invalid request body"}))))?;
+    let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| {
+        (
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({"error": "Invalid request body"})),
+        )
+    })?;
 
     // First verify the collection belongs to this slice
-    let slice_collections = state.database.get_slice_collections_list(&records_params.slice).await
-        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Database error"}))))?;
+    let slice_collections = state
+        .database
+        .get_slice_collections_list(&records_params.slice)
+        .await
+        .map_err(|_| {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(serde_json::json!({"error": "Database error"})),
+            )
+        })?;
 
-    // Special handling: social.slices.lexicon is always allowed as it defines the schema
-    if collection != "social.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err((StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "Collection not found"}))));
+    // Special handling: network.slices.lexicon is always allowed as it defines the schema
+    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
+        return Err((
+            StatusCode::NOT_FOUND,
+            Json(serde_json::json!({"error": "Collection not found"})),
+        ));
     }
 
     // Add collection filter to where conditions
-    let mut where_clause = records_params.where_clause.unwrap_or(crate::models::WhereClause {
-        conditions: HashMap::new(),
-        or_conditions: None,
-    });
-    where_clause.conditions.insert("collection".to_string(), WhereCondition {
-        eq: Some(serde_json::Value::String(collection.clone())),
-        in_values: None,
-        contains: None,
-    });
+    let mut where_clause = records_params
+        .where_clause
+        .unwrap_or(crate::models::WhereClause {
+            conditions: HashMap::new(),
+            or_conditions: None,
+        });
+    where_clause.conditions.insert(
+        "collection".to_string(),
+        WhereCondition {
+            eq: Some(serde_json::Value::String(collection.clone())),
+            in_values: None,
+            contains: None,
+        },
+    );
     records_params.where_clause = Some(where_clause);
 
     // Use the unified database method
-    match state.database.get_slice_collections_records(
-        &records_params.slice,
-        records_params.limit,
-        records_params.cursor.as_deref(),
-        records_params.sort_by.as_ref(),
-        records_params.where_clause.as_ref(),
-    ).await {
+    match state
+        .database
+        .get_slice_collections_records(
+            &records_params.slice,
+            records_params.limit,
+            records_params.cursor.as_deref(),
+            records_params.sort_by.as_ref(),
+            records_params.where_clause.as_ref(),
+        )
+        .await
+    {
         Ok((records, cursor)) => {
             // No need to filter - collection filter is in the SQL query now
 
             // Transform Record to IndexedRecord for the response
-            let indexed_records: Vec<IndexedRecord> = records.into_iter().map(|record| IndexedRecord {
-                uri: record.uri,
-                cid: record.cid,
-                did: record.did,
-                collection: record.collection,
-                value: record.json,
-                indexed_at: record.indexed_at.to_rfc3339(),
-            }).collect();
+            let indexed_records: Vec<IndexedRecord> = records
+                .into_iter()
+                .map(|record| IndexedRecord {
+                    uri: record.uri,
+                    cid: record.cid,
+                    did: record.did,
+                    collection: record.collection,
+                    value: record.json,
+                    indexed_at: record.indexed_at.to_rfc3339(),
+                })
+                .collect();
 
             let output = SliceRecordsOutput {
                 success: true,
···
                 message: None,
             };
 
-            Ok(Json(serde_json::to_value(output)
-                .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Serialization error"}))))?))
-        },
-        Err(_) => Err((StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Database error"})))),
+            Ok(Json(serde_json::to_value(output).map_err(|_| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(serde_json::json!({"error": "Serialization error"})),
+                )
+            })?))
+        }
+        Err(_) => Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({"error": "Database error"})),
+        )),
     }
 }
 
···
     params: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
     // Convert query parameters to SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(params)
-        .map_err(|_| StatusCode::BAD_REQUEST)?;
+    let mut records_params: SliceRecordsParams =
+        serde_json::from_value(params).map_err(|_| StatusCode::BAD_REQUEST)?;
 
     // First verify the collection belongs to this slice
-    let slice_collections = state.database.get_slice_collections_list(&records_params.slice).await
+    let slice_collections = state
+        .database
+        .get_slice_collections_list(&records_params.slice)
+        .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    // Special handling: social.slices.lexicon is always allowed as it defines the schema
-    if collection != "social.slices.lexicon" && !slice_collections.contains(&collection) {
+    // Special handling: network.slices.lexicon is always allowed as it defines the schema
+    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
         return Err(StatusCode::NOT_FOUND);
     }
 
     // Add collection filter to where conditions
-    let mut where_clause = records_params.where_clause.unwrap_or(crate::models::WhereClause {
-        conditions: HashMap::new(),
-        or_conditions: None,
-    });
-    where_clause.conditions.insert("collection".to_string(), WhereCondition {
-        eq: Some(collection.clone().into()),
-        contains: None,
-        in_values: None,
-    });
+    let mut where_clause = records_params
+        .where_clause
+        .unwrap_or(crate::models::WhereClause {
+            conditions: HashMap::new(),
+            or_conditions: None,
+        });
+    where_clause.conditions.insert(
+        "collection".to_string(),
+        WhereCondition {
+            eq: Some(collection.clone().into()),
+            contains: None,
+            in_values: None,
+        },
+    );
     records_params.where_clause = Some(where_clause);
 
-    match state.database.count_slice_collections_records(&records_params.slice, records_params.where_clause.as_ref()).await {
+    match state
+        .database
+        .count_slice_collections_records(
+            &records_params.slice,
+            records_params.where_clause.as_ref(),
+        )
+        .await
+    {
         Ok(count) => Ok(Json(serde_json::json!({
             "success": true,
             "count": count,
···
     body: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
     // Parse the JSON body into SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(body)
-        .map_err(|_| (StatusCode::BAD_REQUEST, Json(serde_json::json!({"error": "Invalid request body"}))))?;
+    let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| {
+        (
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({"error": "Invalid request body"})),
+        )
+    })?;
 
     // First verify the collection belongs to this slice
-    let slice_collections = state.database.get_slice_collections_list(&records_params.slice).await
-        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Database error"}))))?;
+    let slice_collections = state
+        .database
+        .get_slice_collections_list(&records_params.slice)
+        .await
+        .map_err(|_| {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(serde_json::json!({"error": "Database error"})),
+            )
+        })?;
 
-    // Special handling: social.slices.lexicon is always allowed as it defines the schema
-    if collection != "social.slices.lexicon" && !slice_collections.contains(&collection) {
-        return Err((StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "Collection not found"}))));
+    // Special handling: network.slices.lexicon is always allowed as it defines the schema
+    if collection != "network.slices.lexicon" && !slice_collections.contains(&collection) {
+        return Err((
+            StatusCode::NOT_FOUND,
+            Json(serde_json::json!({"error": "Collection not found"})),
+        ));
     }
 
     // Add collection filter to where conditions
-    let mut where_clause = records_params.where_clause.unwrap_or(crate::models::WhereClause {
-        conditions: HashMap::new(),
-        or_conditions: None,
-    });
-    where_clause.conditions.insert("collection".to_string(), WhereCondition {
-        eq: Some(collection.clone().into()),
-        in_values: None,
-        contains: None,
-    });
+    let mut where_clause = records_params
+        .where_clause
+        .unwrap_or(crate::models::WhereClause {
+            conditions: HashMap::new(),
+            or_conditions: None,
+        });
+    where_clause.conditions.insert(
+        "collection".to_string(),
+        WhereCondition {
+            eq: Some(collection.clone().into()),
+            in_values: None,
+            contains: None,
+        },
+    );
     records_params.where_clause = Some(where_clause);
 
-    match state.database.count_slice_collections_records(&records_params.slice, records_params.where_clause.as_ref()).await {
+    match state
+        .database
+        .count_slice_collections_records(
+            &records_params.slice,
+            records_params.where_clause.as_ref(),
+        )
+        .await
+    {
         Ok(count) => Ok(Json(serde_json::json!({
             "success": true,
             "count": count,
···
 ) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
     // Extract and verify OAuth token
     let token = extract_bearer_token(&headers).map_err(status_to_error_response)?;
-    let user_info = verify_oauth_token(&token, &state.config.auth_base_url).await
+    let user_info = verify_oauth_token(&token, &state.config.auth_base_url)
+        .await
         .map_err(status_to_error_response)?;
 
     // Get AT Protocol DPoP auth and PDS URL
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url).await
+    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url)
+        .await
         .map_err(status_to_error_response)?;
 
     // Extract the repo DID from user info
···
     let http_client = reqwest::Client::new();
 
     // Extract slice URI, rkey, and record value from structured body
-    let slice_uri = body.get("slice")
+    let slice_uri = body
+        .get("slice")
         .and_then(|v| v.as_str())
         .ok_or_else(|| status_to_error_response(StatusCode::BAD_REQUEST))?
         .to_string();
 
-    let record_key = body.get("rkey")
+    let record_key = body
+        .get("rkey")
         .and_then(|v| v.as_str())
         .filter(|s| !s.is_empty()) // Filter out empty strings
         .map(|s| s.to_string());
 
-    let record_data = body.get("record")
+    let record_data = body
+        .get("record")
         .ok_or_else(|| status_to_error_response(StatusCode::BAD_REQUEST))?
         .clone();
 
-
     // Validate the record against its lexicon
 
-    // For social.slices.lexicon collection, validate against the system slice
-    let validation_slice_uri = if collection == "social.slices.lexicon" {
-        "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q"
+    // For network.slices.lexicon collection, validate against the system slice
+    let validation_slice_uri = if collection == "network.slices.lexicon" {
+        "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z"
     } else {
         &slice_uri
     };
-
 
     match LexiconValidator::for_slice(&state.database, validation_slice_uri).await {
         Ok(validator) => {
-
             // Debug: Get lexicons from the system slice to see what's there
-            if collection == "social.slices.lexicon" {
-            }
+            if collection == "network.slices.lexicon" {}
 
             if let Err(e) = validator.validate_record(&collection, &record_data) {
-                return Err((StatusCode::BAD_REQUEST, Json(serde_json::json!({
-                    "error": "ValidationError",
-                    "message": format!("Lexicon validation failed: {}", e)
-                }))));
+                return Err((
+                    StatusCode::BAD_REQUEST,
+                    Json(serde_json::json!({
+                        "error": "ValidationError",
+                        "message": format!("Lexicon validation failed: {}", e)
+                    })),
+                ));
             }
-        },
+        }
         Err(e) => {
             // If no lexicon found, continue without validation (backwards compatibility)
             eprintln!("Could not load lexicon validator: {:?}", e);
···
         validate: false,
     };
 
-
     let result = create_record(&http_client, &dpop_auth, &pds_url, create_request)
         .await
-        .map_err(|_e| {
-            status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR)
-        })?;
+        .map_err(|_e| status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR))?;
 
     // Extract URI and CID from the response enum
     let (uri, cid) = match result {
-        CreateRecordResponse::StrongRef { uri, cid, .. } => {
-            (uri, cid)
-        },
+        CreateRecordResponse::StrongRef { uri, cid, .. } => (uri, cid),
         CreateRecordResponse::Error(_e) => {
             return Err(status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR));
-        },
+        }
     };
 
     // Also store in local database for indexing
···
 ) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
     // Extract and verify OAuth token
     let token = extract_bearer_token(&headers).map_err(status_to_error_response)?;
-    let user_info = verify_oauth_token(&token, &state.config.auth_base_url).await
+    let user_info = verify_oauth_token(&token, &state.config.auth_base_url)
+        .await
         .map_err(status_to_error_response)?;
 
     // Get AT Protocol DPoP auth and PDS URL
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url).await
+    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url)
+        .await
         .map_err(status_to_error_response)?;
 
     // Extract slice URI, rkey, and record value from structured body
-    let slice_uri = body.get("slice")
+    let slice_uri = body
+        .get("slice")
         .and_then(|v| v.as_str())
         .ok_or_else(|| status_to_error_response(StatusCode::BAD_REQUEST))?
         .to_string();
 
-    let rkey = body.get("rkey")
+    let rkey = body
+        .get("rkey")
         .and_then(|v| v.as_str())
         .ok_or_else(|| status_to_error_response(StatusCode::BAD_REQUEST))?
         .to_string();
 
-    let record_data = body.get("record")
+    let record_data = body
+        .get("record")
         .ok_or_else(|| status_to_error_response(StatusCode::BAD_REQUEST))?
         .clone();
 
···
     match LexiconValidator::for_slice(&state.database, &slice_uri).await {
         Ok(validator) => {
             if let Err(e) = validator.validate_record(&collection, &record_data) {
-                return Err((StatusCode::BAD_REQUEST, Json(serde_json::json!({
-                    "error": "ValidationError",
-                    "message": format!("Lexicon validation failed: {}", e)
-                }))));
+                return Err((
+                    StatusCode::BAD_REQUEST,
+                    Json(serde_json::json!({
+                        "error": "ValidationError",
+                        "message": format!("Lexicon validation failed: {}", e)
+                    })),
+                ));
             }
-        },
+        }
         Err(e) => {
             // If no lexicon found, continue without validation (backwards compatibility)
             eprintln!("Could not load lexicon validator: {:?}", e);
···
     // Extract URI and CID from the response enum
     let (uri, cid) = match result {
         PutRecordResponse::StrongRef { uri, cid, .. } => (uri, cid),
-        PutRecordResponse::Error(_) => return Err(status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR)),
+        PutRecordResponse::Error(_) => {
+            return Err(status_to_error_response(StatusCode::INTERNAL_SERVER_ERROR));
+        }
     };
 
     // Also update in local database for indexing
···
 ) -> Result<Json<serde_json::Value>, (StatusCode, Json<serde_json::Value>)> {
     // Extract and verify OAuth token
     let token = extract_bearer_token(&headers).map_err(status_to_error_response)?;
-    let user_info = verify_oauth_token(&token, &state.config.auth_base_url).await
+    let user_info = verify_oauth_token(&token, &state.config.auth_base_url)
+        .await
         .map_err(status_to_error_response)?;
 
     // Get AT Protocol DPoP auth and PDS URL
-    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url).await
+    let (dpop_auth, pds_url) = get_atproto_auth_for_user(&token, &state.config.auth_base_url)
+        .await
         .map_err(status_to_error_response)?;
 
     // Extract repo and rkey from body
     let repo = user_info.did.unwrap_or(user_info.sub);
-    let rkey = body["rkey"].as_str()
+    let rkey = body["rkey"]
+        .as_str()
         .ok_or_else(|| status_to_error_response(StatusCode::BAD_REQUEST))?
         .to_string();
 
···
     Ok(Json(serde_json::json!({})))
 }
 
-
 #[cfg(test)]
 mod dynamic_validation_tests {
     use crate::lexicon::LexiconValidator;
     use serde_json::json;
 
     fn create_test_lexicons() -> Vec<serde_json::Value> {
-        vec![
-            json!({
-                "id": "social.slices.testRecord",
-                "lexicon": 1,
-                "defs": {
-                    "main": {
-                        "type": "record",
-                        "record": {
-                            "type": "object",
-                            "required": ["title", "aspectRatio"],
-                            "properties": {
-                                "title": { "type": "string", "maxLength": 100 },
-                                "aspectRatio": { "type": "ref", "ref": "#aspectRatio" }
-                            }
-                        }
-                    },
-                    "aspectRatio": {
+        vec![json!({
+            "id": "network.slices.testRecord",
+            "lexicon": 1,
+            "defs": {
+                "main": {
+                    "type": "record",
+                    "record": {
                         "type": "object",
-                        "required": ["width", "height"],
+                        "required": ["title", "aspectRatio"],
                         "properties": {
-                            "width": { "type": "integer", "minimum": 1 },
-                            "height": { "type": "integer", "minimum": 1 }
+                            "title": { "type": "string", "maxLength": 100 },
+                            "aspectRatio": { "type": "ref", "ref": "#aspectRatio" }
                         }
                     }
+                },
+                "aspectRatio": {
+                    "type": "object",
+                    "required": ["width", "height"],
+                    "properties": {
+                        "width": { "type": "integer", "minimum": 1 },
+                        "height": { "type": "integer", "minimum": 1 }
+                    }
                 }
-            })
-        ]
+            }
+        })]
     }
 
     #[test]
···
             }
         });
 
-        let result = validator.validate_record("social.slices.testRecord", &valid_record);
-        assert!(result.is_ok(), "Valid record should pass validation: {:?}", result);
+        let result = validator.validate_record("network.slices.testRecord", &valid_record);
+        assert!(
+            result.is_ok(),
+            "Valid record should pass validation: {:?}",
+            result
+        );
     }
 
     #[test]
···
             // Missing required aspectRatio field
         });
 
-        let result = validator.validate_record("social.slices.testRecord", &invalid_record);
-        assert!(result.is_err(), "Record missing required field should fail validation");
+        let result = validator.validate_record("network.slices.testRecord", &invalid_record);
+        assert!(
+            result.is_err(),
+            "Record missing required field should fail validation"
+        );
     }
 
     #[test]
···
             }
         });
 
-        let result = validator.validate_record("social.slices.testRecord", &valid_record);
-        assert!(result.is_ok(), "Cross-lexicon reference should work: {:?}", result);
+        let result = validator.validate_record("network.slices.testRecord", &valid_record);
+        assert!(
+            result.is_ok(),
+            "Cross-lexicon reference should work: {:?}",
+            result
+        );
     }
 
     #[test]
···
             // Missing required aspectRatio field
         });
 
-        let result = validator.validate_record("social.slices.testRecord", &invalid_record);
+        let result = validator.validate_record("network.slices.testRecord", &invalid_record);
         assert!(result.is_err(), "Invalid record should fail validation");
 
         if let Err(e) = result {
             let error_message = format!("{}", e);
-            assert!(!error_message.is_empty(), "Error message should not be empty");
+            assert!(
+                !error_message.is_empty(),
+                "Error message should not be empty"
+            );
             // Error message should be user-friendly and descriptive
-            assert!(error_message.contains("aspectRatio") || error_message.contains("required"),
-                   "Error message should indicate what's wrong: {}", error_message);
+            assert!(
+                error_message.contains("aspectRatio") || error_message.contains("required"),
+                "Error message should indicate what's wrong: {}",
+                error_message
+            );
         }
     }
 
···
             }
         });
 
-        let result = validator.validate_record("social.slices.testRecord", &invalid_record);
-        assert!(result.is_err(), "Constraint violation should fail validation");
+        let result = validator.validate_record("network.slices.testRecord", &invalid_record);
+        assert!(
+            result.is_err(),
+            "Constraint violation should fail validation"
+        );
 
         if let Err(e) = result {
             let error_message = format!("{}", e);
             // Should indicate the specific constraint that was violated
-            assert!(error_message.contains("length") || error_message.contains("maximum") || error_message.contains("100"),
-                   "Error message should indicate length constraint: {}", error_message);
+            assert!(
+                error_message.contains("length")
+                    || error_message.contains("maximum")
+                    || error_message.contains("100"),
+                "Error message should indicate length constraint: {}",
+                error_message
+            );
         }
     }
 }

api/src/lexicon/test.rs

···
                             "required": [
                                 "object",
                                 "array",
-                                "boolean", 
+                                "boolean",
                                 "integer",
                                 "string",
                                 "bytes",
···
                         }
                     }
                 }
-            })
+            }),
         ]
     }
 
     #[test]
     fn test_kitchen_sink_validation() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid kitchen sink record (mirroring TypeScript test)
         let valid_record = json!({
             "object": {
···
                 "$link": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
             }
         });
-        
-        assert!(validator.validate_record("com.example.kitchenSink", &valid_record).is_ok());
-        
+
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &valid_record)
+                .is_ok()
+        );
+
         // Missing required field (object)
         let invalid_record = json!({
             "array": ["one", "two"],
···
                 "$link": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
             }
         });
-        
-        assert!(validator.validate_record("com.example.kitchenSink", &invalid_record).is_err());
+
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &invalid_record)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_local_refs() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid with local ref (#object -> #subobject)
         let valid_record = json!({
             "object": { "boolean": true }, // subobject ref
···
             "integer": 123,
             "string": "string"
         });
-        
-        assert!(validator.validate_record("com.example.kitchenSink#object", &valid_record).is_ok());
-        
+
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink#object", &valid_record)
+                .is_ok()
+        );
+
         // Invalid - missing boolean in subobject
         let invalid_record = json!({
             "object": {}, // missing required boolean
-            "array": ["one", "two"], 
+            "array": ["one", "two"],
             "boolean": true,
             "integer": 123,
             "string": "string"
         });
-        
-        assert!(validator.validate_record("com.example.kitchenSink#object", &invalid_record).is_err());
+
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink#object", &invalid_record)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_array_length_constraints() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid array length
         let valid = json!({ "array": [1, 2, 3] });
-        assert!(validator.validate_record("com.example.arrayLength", &valid).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.arrayLength", &valid)
+                .is_ok()
+        );
+
         // Too short
         let too_short = json!({ "array": [1] });
-        assert!(validator.validate_record("com.example.arrayLength", &too_short).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.arrayLength", &too_short)
+                .is_err()
+        );
+
         // Too long
         let too_long = json!({ "array": [1, 2, 3, 4, 5] });
-        assert!(validator.validate_record("com.example.arrayLength", &too_long).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.arrayLength", &too_long)
+                .is_err()
+        );
+
         // Wrong item type
         let wrong_type = json!({ "array": [1, "2", 3] });
-        assert!(validator.validate_record("com.example.arrayLength", &wrong_type).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.arrayLength", &wrong_type)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_boolean_const_constraint() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid const
         let valid = json!({ "boolean": false });
-        assert!(validator.validate_record("com.example.boolConst", &valid).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.boolConst", &valid)
+                .is_ok()
+        );
+
         // Invalid const
         let invalid = json!({ "boolean": true });
-        assert!(validator.validate_record("com.example.boolConst", &invalid).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.boolConst", &invalid)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_integer_constraints() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Range test - valid
         let valid_range = json!({ "integer": 2 });
-        assert!(validator.validate_record("com.example.integerRange", &valid_range).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.integerRange", &valid_range)
+                .is_ok()
+        );
+
         // Range test - too low
         let too_low = json!({ "integer": 1 });
-        assert!(validator.validate_record("com.example.integerRange", &too_low).is_err());
-        
-        // Range test - too high  
+        assert!(
+            validator
+                .validate_record("com.example.integerRange", &too_low)
+                .is_err()
+        );
+
+        // Range test - too high
         let too_high = json!({ "integer": 5 });
-        assert!(validator.validate_record("com.example.integerRange", &too_high).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.integerRange", &too_high)
+                .is_err()
+        );
+
         // Enum test - valid
         let valid_enum = json!({ "integer": 2 });
-        assert!(validator.validate_record("com.example.integerEnum", &valid_enum).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.integerEnum", &valid_enum)
+                .is_ok()
+        );
+
         // Enum test - invalid
         let invalid_enum = json!({ "integer": 0 });
-        assert!(validator.validate_record("com.example.integerEnum", &invalid_enum).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.integerEnum", &invalid_enum)
+                .is_err()
+        );
+
         // Const test - valid
         let valid_const = json!({ "integer": 0 });
-        assert!(validator.validate_record("com.example.integerConst", &valid_const).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.integerConst", &valid_const)
+                .is_ok()
+        );
+
         // Const test - invalid
         let invalid_const = json!({ "integer": 1 });
-        assert!(validator.validate_record("com.example.integerConst", &invalid_const).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.integerConst", &invalid_const)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_string_constraints() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Length test - valid
         let valid_length = json!({ "string": "ab" });
-        assert!(validator.validate_record("com.example.stringLength", &valid_length).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringLength", &valid_length)
+                .is_ok()
+        );
+
         let valid_length_max = json!({ "string": "abcd" });
-        assert!(validator.validate_record("com.example.stringLength", &valid_length_max).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringLength", &valid_length_max)
+                .is_ok()
+        );
+
         // Length test - too short
         let too_short = json!({ "string": "a" });
-        assert!(validator.validate_record("com.example.stringLength", &too_short).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringLength", &too_short)
+                .is_err()
+        );
+
         // Length test - too long
         let too_long = json!({ "string": "abcde" });
-        assert!(validator.validate_record("com.example.stringLength", &too_long).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringLength", &too_long)
+                .is_err()
+        );
+
         // Enum test - valid
         let valid_enum = json!({ "string": "a" });
-        assert!(validator.validate_record("com.example.stringEnum", &valid_enum).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringEnum", &valid_enum)
+                .is_ok()
+        );
+
         // Enum test - invalid
         let invalid_enum = json!({ "string": "c" });
-        assert!(validator.validate_record("com.example.stringEnum", &invalid_enum).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringEnum", &invalid_enum)
+                .is_err()
+        );
+
         // Const test - valid
         let valid_const = json!({ "string": "a" });
-        assert!(validator.validate_record("com.example.stringConst", &valid_const).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.stringConst", &valid_const)
+                .is_ok()
+        );
+
         // Const test - invalid
         let invalid_const = json!({ "string": "b" });
-        assert!(validator.validate_record("com.example.stringConst", &invalid_const).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.stringConst", &invalid_const)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_string_formats() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // DateTime format tests (matching TypeScript test cases)
         let valid_datetimes = vec![
             "2022-12-12T00:50:36.809Z",
-            "2022-12-12T00:50:36Z", 
+            "2022-12-12T00:50:36Z",
             "2022-12-12T00:50:36.8Z",
             "2022-12-12T00:50:36.80Z",
             "2022-12-12T00:50:36+00:00",
···
             "2022-12-11T19:50:36-05:00",
             "2022-12-11T19:50:36.8-05:00",
             "2022-12-11T19:50:36.80-05:00",
-            "2022-12-11T19:50:36.809-05:00"
+            "2022-12-11T19:50:36.809-05:00",
         ];
-        
+
         for datetime in valid_datetimes {
             let record = json!({ "datetime": datetime });
-            assert!(validator.validate_record("com.example.datetime", &record).is_ok(),
-                    "Should accept datetime: {}", datetime);
+            assert!(
+                validator
+                    .validate_record("com.example.datetime", &record)
+                    .is_ok(),
+                "Should accept datetime: {}",
+                datetime
+            );
         }
-        
+
         let invalid_datetime = json!({ "datetime": "bad date" });
-        assert!(validator.validate_record("com.example.datetime", &invalid_datetime).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.datetime", &invalid_datetime)
+                .is_err()
+        );
+
         // URI format tests
         let valid_uris = vec![
             "https://example.com",
             "https://example.com/with/path",
             "https://example.com/with/path?and=query",
-            "at://bsky.social", 
-            "did:example:test"
+            "at://bsky.social",
+            "did:example:test",
         ];
-        
+
         for uri in valid_uris {
             let record = json!({ "uri": uri });
-            assert!(validator.validate_record("com.example.uri", &record).is_ok(),
-                    "Should accept URI: {}", uri);
+            assert!(
+                validator
+                    .validate_record("com.example.uri", &record)
+                    .is_ok(),
+                "Should accept URI: {}",
+                uri
+            );
         }
-        
+
         let invalid_uri = json!({ "uri": "not a uri" });
-        assert!(validator.validate_record("com.example.uri", &invalid_uri).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.uri", &invalid_uri)
+                .is_err()
+        );
+
         // AT-URI format test
         let valid_at_uri = json!({ "atUri": "at://did:web:example.com/com.example.test/self" });
-        assert!(validator.validate_record("com.example.atUri", &valid_at_uri).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.atUri", &valid_at_uri)
+                .is_ok()
+        );
+
         let invalid_at_uri = json!({ "atUri": "http://not-atproto.com" });
-        assert!(validator.validate_record("com.example.atUri", &invalid_at_uri).is_err());
-        
-        // DID format tests  
-        let valid_dids = vec![
-            "did:web:example.com",
-            "did:plc:12345678abcdefghijklmnop"
-        ];
-        
+        assert!(
+            validator
+                .validate_record("com.example.atUri", &invalid_at_uri)
+                .is_err()
+        );
+
+        // DID format tests
+        let valid_dids = vec!["did:web:example.com", "did:plc:12345678abcdefghijklmnop"];
+
         for did in valid_dids {
             let record = json!({ "did": did });
-            assert!(validator.validate_record("com.example.did", &record).is_ok(),
-                    "Should accept DID: {}", did);
+            assert!(
+                validator
+                    .validate_record("com.example.did", &record)
+                    .is_ok(),
+                "Should accept DID: {}",
+                did
+            );
         }
-        
+
         let invalid_dids = vec!["bad did", "did:short"];
-        
+
         for did in invalid_dids {
             let record = json!({ "did": did });
-            assert!(validator.validate_record("com.example.did", &record).is_err(),
-                    "Should reject DID: {}", did);
+            assert!(
+                validator
+                    .validate_record("com.example.did", &record)
+                    .is_err(),
+                "Should reject DID: {}",
+                did
+            );
         }
-        
+
         // Handle format tests
-        let valid_handles = vec![
-            "test.bsky.social",
-            "bsky.test"
-        ];
-        
+        let valid_handles = vec!["test.bsky.social", "bsky.test"];
+
         for handle in valid_handles {
             let record = json!({ "handle": handle });
-            assert!(validator.validate_record("com.example.handle", &record).is_ok(),
-                    "Should accept handle: {}", handle);
+            assert!(
+                validator
+                    .validate_record("com.example.handle", &record)
+                    .is_ok(),
+                "Should accept handle: {}",
+                handle
+            );
         }
-        
+
         let invalid_handles = vec!["bad handle", "-bad-.test"];
-        
+
         for handle in invalid_handles {
             let record = json!({ "handle": handle });
-            assert!(validator.validate_record("com.example.handle", &record).is_err(),
-                    "Should reject handle: {}", handle);
+            assert!(
+                validator
+                    .validate_record("com.example.handle", &record)
+                    .is_err(),
+                "Should reject handle: {}",
+                handle
+            );
         }
-        
+
         // AT-identifier format tests
-        let valid_at_identifiers = vec![
-            "bsky.test",
-            "did:plc:12345678abcdefghijklmnop"
-        ];
-        
+        let valid_at_identifiers = vec!["bsky.test", "did:plc:12345678abcdefghijklmnop"];
+
         for at_id in valid_at_identifiers {
             let record = json!({ "atIdentifier": at_id });
-            assert!(validator.validate_record("com.example.atIdentifier", &record).is_ok(),
-                    "Should accept at-identifier: {}", at_id);
+            assert!(
+                validator
+                    .validate_record("com.example.atIdentifier", &record)
+                    .is_ok(),
+                "Should accept at-identifier: {}",
+                at_id
+            );
         }
-        
+
         let invalid_at_identifiers = vec!["bad id", "-bad-.test"];
-        
+
         for at_id in invalid_at_identifiers {
             let record = json!({ "atIdentifier": at_id });
-            assert!(validator.validate_record("com.example.atIdentifier", &record).is_err(),
-                    "Should reject at-identifier: {}", at_id);
+            assert!(
+                validator
+                    .validate_record("com.example.atIdentifier", &record)
+                    .is_err(),
+                "Should reject at-identifier: {}",
+                at_id
+            );
         }
-        
+
         // NSID format tests
-        let valid_nsids = vec![
-            "com.atproto.test",
-            "app.bsky.nested.test"
-        ];
-        
+        let valid_nsids = vec!["com.atproto.test", "app.bsky.nested.test"];
+
         for nsid in valid_nsids {
             let record = json!({ "nsid": nsid });
-            assert!(validator.validate_record("com.example.nsid", &record).is_ok(),
-                    "Should accept NSID: {}", nsid);
+            assert!(
+                validator
+                    .validate_record("com.example.nsid", &record)
+                    .is_ok(),
+                "Should accept NSID: {}",
+                nsid
+            );
         }
-        
+
         let invalid_nsids = vec!["bad nsid", "com.bad-.foo"];
-        
+
         for nsid in invalid_nsids {
             let record = json!({ "nsid": nsid });
-            assert!(validator.validate_record("com.example.nsid", &record).is_err(),
-                    "Should reject NSID: {}", nsid);
+            assert!(
+                validator
+                    .validate_record("com.example.nsid", &record)
+                    .is_err(),
+                "Should reject NSID: {}",
+                nsid
+            );
         }
-        
+
         // CID format test
-        let valid_cid = json!({ "cid": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a" });
-        assert!(validator.validate_record("com.example.cid", &valid_cid).is_ok());
-        
+        let valid_cid =
+            json!({ "cid": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a" });
+        assert!(
+            validator
+                .validate_record("com.example.cid", &valid_cid)
+                .is_ok()
+        );
+
         let invalid_cid = json!({ "cid": "abapsdofiuwrpoiasdfuaspdfoiu" });
-        assert!(validator.validate_record("com.example.cid", &invalid_cid).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.cid", &invalid_cid)
+                .is_err()
+        );
+
         // Language format test
         let valid_language = json!({ "language": "en-US-boont" });
-        assert!(validator.validate_record("com.example.language", &valid_language).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.language", &valid_language)
+                .is_ok()
+        );
+
         let invalid_language = json!({ "language": "not-a-language-" });
-        assert!(validator.validate_record("com.example.language", &invalid_language).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.language", &invalid_language)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_bytes_validation() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid bytes (base64, 3 bytes when decoded)
         let valid_bytes = json!({ "bytes": "SGVs" }); // 3 bytes when decoded
-        assert!(validator.validate_record("com.example.byteLength", &valid_bytes).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.byteLength", &valid_bytes)
+                .is_ok()
+        );
+
         // Too short (1 byte when decoded)
         let too_short = json!({ "bytes": "SA==" });
-        assert!(validator.validate_record("com.example.byteLength", &too_short).is_err());
-        
-        // Too long (5+ bytes when decoded) 
+        assert!(
+            validator
+                .validate_record("com.example.byteLength", &too_short)
+                .is_err()
+        );
+
+        // Too long (5+ bytes when decoded)
         let too_long = json!({ "bytes": "SGVsbG9Xb3JsZA==" }); // "HelloWorld" is 10 bytes
-        assert!(validator.validate_record("com.example.byteLength", &too_long).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.byteLength", &too_long)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_union_validation() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid union - open union with object variant
         let valid_union = json!({
             "unionOpen": {
···
                 "string": "string"
             },
             "unionClosed": {
-                "$type": "com.example.kitchenSink#subobject", 
+                "$type": "com.example.kitchenSink#subobject",
                 "boolean": true
             }
         });
-        
-        assert!(validator.validate_record("com.example.union", &valid_union).is_ok());
-        
+
+        assert!(
+            validator
+                .validate_record("com.example.union", &valid_union)
+                .is_ok()
+        );
+
         // Valid union - open union with other type
         let valid_open = json!({
             "unionOpen": {
···
             },
             "unionClosed": {
                 "$type": "com.example.kitchenSink#subobject",
-                "boolean": true  
+                "boolean": true
             }
         });
-        
+
         // This should work for open unions (they allow unknown types)
-        assert!(validator.validate_record("com.example.union", &valid_open).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.union", &valid_open)
+                .is_ok()
+        );
+
         // Missing $type in union
         let missing_type = json!({
             "unionOpen": {},
             "unionClosed": {}
         });
-        
-        assert!(validator.validate_record("com.example.union", &missing_type).is_err());
+
+        assert!(
+            validator
+                .validate_record("com.example.union", &missing_type)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_unknown_type() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         // Valid unknown field
         let valid_unknown = json!({ "unknown": { "foo": "bar" } });
-        assert!(validator.validate_record("com.example.unknown", &valid_unknown).is_ok());
-        
+        assert!(
+            validator
+                .validate_record("com.example.unknown", &valid_unknown)
+                .is_ok()
+        );
+
         // Missing required unknown field
         let missing_unknown = json!({});
-        assert!(validator.validate_record("com.example.unknown", &missing_unknown).is_err());
+        assert!(
+            validator
+                .validate_record("com.example.unknown", &missing_unknown)
+                .is_err()
+        );
     }
-    
-    #[test] 
+
+    #[test]
     fn test_type_validation_errors() {
         let validator = LexiconValidator::new(get_test_lexicons()).unwrap();
-        
+
         let base_record = json!({
             "object": {
                 "object": { "boolean": true },
···
                 "$link": "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a"
             }
         });
-        
+
         // Wrong boolean type
         let mut bad_boolean = base_record.clone();
         bad_boolean["object"]["object"]["boolean"] = json!("not boolean");
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_boolean).is_err());
-        
-        // Wrong object type  
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_boolean)
+                .is_err()
+        );
+
+        // Wrong object type
         let mut bad_object = base_record.clone();
         bad_object["object"] = json!(true);
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_object).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_object)
+                .is_err()
+        );
+
         // Wrong array type
         let mut bad_array = base_record.clone();
         bad_array["array"] = json!(1234);
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_array).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_array)
+                .is_err()
+        );
+
         // Wrong integer type
         let mut bad_integer = base_record.clone();
         bad_integer["integer"] = json!(true);
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_integer).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_integer)
+                .is_err()
+        );
+
         // Wrong string type
         let mut bad_string = base_record.clone();
         bad_string["string"] = json!({});
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_string).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_string)
+                .is_err()
+        );
+
         // Wrong bytes type
         let mut bad_bytes = base_record.clone();
         bad_bytes["bytes"] = json!(1234);
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_bytes).is_err());
-        
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_bytes)
+                .is_err()
+        );
+
         // Wrong CID link type
         let mut bad_cid_link = base_record.clone();
-        bad_cid_link["cidLink"] = json!("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a");
-        assert!(validator.validate_record("com.example.kitchenSink", &bad_cid_link).is_err());
+        bad_cid_link["cidLink"] =
+            json!("bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a");
+        assert!(
+            validator
+                .validate_record("com.example.kitchenSink", &bad_cid_link)
+                .is_err()
+        );
     }
-    
+
     #[test]
     fn test_lexicon_definitions_validation() {
         let lexicons = vec![serde_json::json!({
-            "id": "social.slices.lexicon",
+            "id": "network.slices.lexicon",
             "defs": {
                 "main": {
                     "type": "record",
···
                 }
             }
         })];
-        
+
         let validator = LexiconValidator::new(lexicons).unwrap();
-        
+
         // Valid lexicon record with valid definitions JSON
         let valid_record = serde_json::json!({
             "nsid": "com.example.test",
             "definitions": r#"{"main": {"type": "record", "record": {"type": "object", "properties": {"title": {"type": "string"}}}}}"#
         });
-        
-        let result = validator.validate_record("social.slices.lexicon", &valid_record);
-        assert!(result.is_ok(), "Valid lexicon definitions should pass: {:?}", result);
-        
+
+        let result = validator.validate_record("network.slices.lexicon", &valid_record);
+        assert!(
+            result.is_ok(),
+            "Valid lexicon definitions should pass: {:?}",
+            result
+        );
+
         // Invalid JSON in definitions field
         let invalid_json_record = serde_json::json!({
-            "nsid": "com.example.test", 
+            "nsid": "com.example.test",
             "definitions": r#"{"main": invalid json}"#
         });
-        
-        let result = validator.validate_record("social.slices.lexicon", &invalid_json_record);
+
+        let result = validator.validate_record("network.slices.lexicon", &invalid_json_record);
         assert!(result.is_err());
-        assert!(result.unwrap_err().to_string().contains("Invalid JSON in definitions field"));
-        
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("Invalid JSON in definitions field")
+        );
+
         // Invalid lexicon structure (missing type)
         let invalid_structure_record = serde_json::json!({
             "nsid": "com.example.test",
             "definitions": r#"{"main": {"record": {"type": "object"}}}"#
         });
-        
-        let result = validator.validate_record("social.slices.lexicon", &invalid_structure_record);
+
+        let result = validator.validate_record("network.slices.lexicon", &invalid_structure_record);
         assert!(result.is_err());
-        assert!(result.unwrap_err().to_string().contains("missing required 'type' field"));
-        
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("missing required 'type' field")
+        );
+
         // Invalid definition name (with hyphen - not camelCase)
         let invalid_name_record = serde_json::json!({
             "nsid": "com.example.test",
             "definitions": r#"{"my-invalid-name": {"type": "object"}}"#
         });
-        
-        let result = validator.validate_record("social.slices.lexicon", &invalid_name_record);
+
+        let result = validator.validate_record("network.slices.lexicon", &invalid_name_record);
         assert!(result.is_err());
-        assert!(result.unwrap_err().to_string().contains("must be camelCase"));
-        
+        assert!(
+            result
+                .unwrap_err()
+                .to_string()
+                .contains("must be camelCase")
+        );
+
         // Valid camelCase definition names should work
         let valid_camel_record = serde_json::json!({
             "nsid": "com.example.test",
             "definitions": r#"{"listViewBasic": {"type": "object"}, "starterPackView": {"type": "object"}}"#
         });
-        
-        let result = validator.validate_record("social.slices.lexicon", &valid_camel_record);
-        assert!(result.is_ok(), "CamelCase definition names should be valid: {:?}", result);
+
+        let result = validator.validate_record("network.slices.lexicon", &valid_camel_record);
+        assert!(
+            result.is_ok(),
+            "CamelCase definition names should be valid: {:?}",
+            result
+        );
     }
-    
+
     #[test]
     fn test_lexicon_set_completeness_validation() {
         // Test with complete lexicon set (should pass)
···
                         }
                     }
                 }
-            })
+            }),
         ];
-        
+
         let validator = LexiconValidator::new(complete_lexicons).unwrap();
         let result = validator.validate_lexicon_set_completeness();
-        assert!(result.is_ok(), "Complete lexicon set should pass validation");
-        
-        // Test with missing lexicon reference (should fail)  
-        let incomplete_lexicons = vec![
-            serde_json::json!({
-                "id": "com.example.posts",
-                "defs": {
-                    "main": {
-                        "type": "record",
-                        "record": {
-                            "type": "object",
-                            "properties": {
-                                "author": { "type": "ref", "ref": "com.example.missing#user" },
-                                "content": { "type": "string" }
-                            }
+        assert!(
+            result.is_ok(),
+            "Complete lexicon set should pass validation"
+        );
+
+        // Test with missing lexicon reference (should fail)
+        let incomplete_lexicons = vec![serde_json::json!({
+            "id": "com.example.posts",
+            "defs": {
+                "main": {
+                    "type": "record",
+                    "record": {
+                        "type": "object",
+                        "properties": {
+                            "author": { "type": "ref", "ref": "com.example.missing#user" },
+                            "content": { "type": "string" }
                         }
                     }
                 }
-            })
-        ];
-        
+            }
+        })];
+
         let validator = LexiconValidator::new(incomplete_lexicons).unwrap();
         let result = validator.validate_lexicon_set_completeness();
         assert!(result.is_err());
-        assert!(result.unwrap_err().contains("Missing lexicon 'com.example.missing'"));
-        
+        assert!(
+            result
+                .unwrap_err()
+                .contains("Missing lexicon 'com.example.missing'")
+        );
+
         // Test with local references (should pass - local refs are valid)
-        let local_ref_lexicons = vec![
-            serde_json::json!({
-                "id": "com.example.media",
-                "defs": {
-                    "main": {
-                        "type": "record",
-                        "record": {
-                            "type": "object",
-                            "properties": {
-                                "image": { "type": "ref", "ref": "#imageObject" }
-                            }
-                        }
-                    },
-                    "imageObject": {
+        let local_ref_lexicons = vec![serde_json::json!({
+            "id": "com.example.media",
+            "defs": {
+                "main": {
+                    "type": "record",
+                    "record": {
                         "type": "object",
                         "properties": {
-                            "url": { "type": "string" }
+                            "image": { "type": "ref", "ref": "#imageObject" }
                         }
                     }
+                },
+                "imageObject": {
+                    "type": "object",
+                    "properties": {
+                        "url": { "type": "string" }
+                    }
                 }
-            })
-        ];
-        
+            }
+        })];
+
         let validator = LexiconValidator::new(local_ref_lexicons).unwrap();
         let result = validator.validate_lexicon_set_completeness();
-        assert!(result.is_ok(), "Local references should not cause validation errors");
-        
+        assert!(
+            result.is_ok(),
+            "Local references should not cause validation errors"
+        );
+
         // Test with direct lexicon reference (no # fragment)
-        let direct_ref_lexicons = vec![
-            serde_json::json!({
-                "id": "com.example.gallery",
-                "defs": {
-                    "main": {
-                        "type": "record",
-                        "record": {
-                            "type": "object",
-                            "properties": {
-                                "facets": {
-                                    "type": "array",
-                                    "items": {
-                                        "type": "ref",
-                                        "ref": "app.bsky.richtext.facet"
-                                    }
+        let direct_ref_lexicons = vec![serde_json::json!({
+            "id": "com.example.gallery",
+            "defs": {
+                "main": {
+                    "type": "record",
+                    "record": {
+                        "type": "object",
+                        "properties": {
+                            "facets": {
+                                "type": "array",
+                                "items": {
+                                    "type": "ref",
+                                    "ref": "app.bsky.richtext.facet"
                                 }
                             }
                         }
                     }
                 }
-            })
-        ];
-        
+            }
+        })];
+
         let validator = LexiconValidator::new(direct_ref_lexicons).unwrap();
         let result = validator.validate_lexicon_set_completeness();
         assert!(result.is_err());
-        assert!(result.unwrap_err().contains("Missing lexicon 'app.bsky.richtext.facet'"));
-        
+        assert!(
+            result
+                .unwrap_err()
+                .contains("Missing lexicon 'app.bsky.richtext.facet'")
+        );
+
         // Test with union refs array
-        let union_refs_lexicons = vec![
-            serde_json::json!({
-                "id": "com.example.content",
-                "defs": {
-                    "main": {
-                        "type": "record",
-                        "record": {
-                            "type": "object",
-                            "properties": {
-                                "subject": {
-                                    "type": "union",
-                                    "refs": [
-                                        "com.example.missing#post",
-                                        "app.bsky.feed.post"
-                                    ]
-                                }
+        let union_refs_lexicons = vec![serde_json::json!({
+            "id": "com.example.content",
+            "defs": {
+                "main": {
+                    "type": "record",
+                    "record": {
+                        "type": "object",
+                        "properties": {
+                            "subject": {
+                                "type": "union",
+                                "refs": [
+                                    "com.example.missing#post",
+                                    "app.bsky.feed.post"
+                                ]
                             }
                         }
                     }
                 }
-            })
-        ];
-        
+            }
+        })];
+
         let validator = LexiconValidator::new(union_refs_lexicons).unwrap();
         let result = validator.validate_lexicon_set_completeness();
         assert!(result.is_err());
         let error_msg = result.unwrap_err();
         assert!(error_msg.contains("Missing lexicon 'com.example.missing'"));
         assert!(error_msg.contains("Missing lexicon 'app.bsky.feed.post'"));
-        
+
         // Test that validation passes when all references are present
         let complete_with_direct_refs = vec![
             serde_json::json!({
···
                         }
                     }
                 }
-            })
+            }),
         ];
-        
+
         let validator = LexiconValidator::new(complete_with_direct_refs).unwrap();
         let result = validator.validate_lexicon_set_completeness();
-        assert!(result.is_ok(), "Should pass when all direct references are present");
+        assert!(
+            result.is_ok(),
+            "Should pass when all direct references are present"
+        );
     }
-}
+}

api/src/lexicon/validator.rs

···
-use std::collections::HashMap;
-use serde_json::Value;
 use chrono::DateTime;
 use regex::Regex;
+use serde_json::Value;
+use std::collections::HashMap;
 
-use crate::database::Database;
 use super::errors::ValidationError;
 use super::types::{LexiconDoc, StringFormat, ValidationContext};
+use crate::database::Database;
 
 #[derive(Clone)]
 pub struct LexiconValidator {
···
     /// Create a new validator with the given lexicon documents
     pub fn new(lexicons: Vec<Value>) -> Result<Self, ValidationError> {
         let mut lexicon_map = HashMap::new();
-        
+
         for lexicon_value in lexicons {
             let id = lexicon_value["id"]
                 .as_str()
                 .ok_or_else(|| ValidationError::InvalidSchema("Missing lexicon id".to_string()))?
                 .to_string();
-            
+
             let defs = lexicon_value["defs"].clone();
             if defs.is_null() {
-                return Err(ValidationError::InvalidSchema(format!("Missing defs in lexicon {}", id)));
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Missing defs in lexicon {}",
+                    id
+                )));
             }
-            
+
             lexicon_map.insert(id.clone(), LexiconDoc { id, defs });
         }
-        
-        Ok(Self { lexicons: lexicon_map })
+
+        Ok(Self {
+            lexicons: lexicon_map,
+        })
     }
-    
+
     /// Load lexicons for a specific slice from the database
     pub async fn for_slice(db: &Database, slice_uri: &str) -> Result<Self, ValidationError> {
-        let lexicon_records = db.get_lexicons_by_slice(slice_uri)
-            .await
-            .map_err(|e| ValidationError::Unknown {
-                path: "database".to_string(),
-                message: e.to_string(),
-            })?;
-        
+        let lexicon_records =
+            db.get_lexicons_by_slice(slice_uri)
+                .await
+                .map_err(|e| ValidationError::Unknown {
+                    path: "database".to_string(),
+                    message: e.to_string(),
+                })?;
+
         // lexicon_records already has the correct format from get_lexicons_by_slice
         let lexicons: Vec<serde_json::Value> = lexicon_records
             .into_iter()
···
                 lexicon
             })
             .collect();
-        
+
         Self::new(lexicons)
     }
-    
+
     /// Validate a record against its collection's lexicon
     pub fn validate_record(&self, collection: &str, record: &Value) -> Result<(), ValidationError> {
         // Parse collection string which might have fragment (#object, #main, etc)
         let parts: Vec<&str> = collection.split('#').collect();
         let nsid = parts[0];
         let fragment = parts.get(1).map(|s| *s).unwrap_or("main");
-        
-        let lexicon = self.lexicons.get(nsid)
+
+        let lexicon = self
+            .lexicons
+            .get(nsid)
             .ok_or_else(|| ValidationError::LexiconNotFound(nsid.to_string()))?;
-        
+
         // Get the definition schema
         let def_schema = &lexicon.defs[fragment];
         if def_schema.is_null() {
-            return Err(ValidationError::InvalidSchema(
-                format!("No {} definition in lexicon {}", fragment, nsid)
-            ));
+            return Err(ValidationError::InvalidSchema(format!(
+                "No {} definition in lexicon {}",
+                fragment, nsid
+            )));
         }
-        
+
         // For record types, validate against the record schema
         let record_schema = if def_schema["type"] == "record" {
             &def_schema["record"]
···
             // For other types like object, validate directly
             def_schema
         };
-        
+
         let ctx = ValidationContext::new();
-        
-        // Special validation for social.slices.lexicon records
-        if nsid == "social.slices.lexicon" {
+
+        // Special validation for network.slices.lexicon records
+        if nsid == "network.slices.lexicon" {
             self.validate_lexicon_record(record, record_schema, &ctx)?;
         } else {
             self.validate_value(record, record_schema, &ctx)?;
         }
-        
+
         Ok(())
     }
-    
-    /// Special validation for social.slices.lexicon records
-    fn validate_lexicon_record(&self, record: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
+
+    /// Special validation for network.slices.lexicon records
+    fn validate_lexicon_record(
+        &self,
+        record: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         // First, validate against the normal schema
         self.validate_value(record, schema, ctx)?;
-        
+
         // Then, validate that the "definitions" field contains valid lexicon JSON
         if let Some(definitions_str) = record.get("definitions").and_then(|v| v.as_str()) {
             // Parse the definitions JSON
-            let definitions_json: Value = serde_json::from_str(definitions_str)
-                .map_err(|e| ValidationError::InvalidSchema(
-                    format!("Invalid JSON in definitions field: {}", e)
-                ))?;
-            
+            let definitions_json: Value = serde_json::from_str(definitions_str).map_err(|e| {
+                ValidationError::InvalidSchema(format!("Invalid JSON in definitions field: {}", e))
+            })?;
+
             // Validate that it looks like a proper lexicon definition
             self.validate_lexicon_definitions(&definitions_json)?;
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate that a JSON value contains valid lexicon definitions
     fn validate_lexicon_definitions(&self, definitions: &Value) -> Result<(), ValidationError> {
-        let definitions_obj = definitions.as_object()
-            .ok_or_else(|| ValidationError::InvalidSchema(
-                "Lexicon definitions must be a JSON object".to_string()
-            ))?;
-        
+        let definitions_obj = definitions.as_object().ok_or_else(|| {
+            ValidationError::InvalidSchema("Lexicon definitions must be a JSON object".to_string())
+        })?;
+
         // Each key should be a valid definition name, each value should be a valid definition
         for (def_name, def_value) in definitions_obj {
             // Validate definition name (should be camelCase identifier - letters and numbers only)
             if def_name.is_empty() || !def_name.chars().all(|c| c.is_ascii_alphanumeric()) {
-                return Err(ValidationError::InvalidSchema(
-                    format!("Invalid definition name '{}': must be camelCase (letters and numbers only)", def_name)
-                ));
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Invalid definition name '{}': must be camelCase (letters and numbers only)",
+                    def_name
+                )));
             }
-            
+
             // Validate definition structure
-            let def_type = def_value.get("type")
+            let def_type = def_value
+                .get("type")
                 .and_then(|v| v.as_str())
-                .ok_or_else(|| ValidationError::InvalidSchema(
-                    format!("Definition '{}' missing required 'type' field", def_name)
-                ))?;
-            
+                .ok_or_else(|| {
+                    ValidationError::InvalidSchema(format!(
+                        "Definition '{}' missing required 'type' field",
+                        def_name
+                    ))
+                })?;
+
             // Validate based on definition type
             match def_type {
                 "record" => self.validate_record_definition(def_name, def_value)?,
                 "object" => self.validate_object_definition(def_name, def_value)?,
-                "string" | "integer" | "boolean" | "array" | "union" | "ref" | "blob" | "bytes" | "cid-link" | "unknown" => {
+                "string" | "integer" | "boolean" | "array" | "union" | "ref" | "blob" | "bytes"
+                | "cid-link" | "unknown" => {
                     // Basic types are valid, could add more specific validation here
-                },
-                _ => return Err(ValidationError::InvalidSchema(
-                    format!("Definition '{}' has unknown type '{}'", def_name, def_type)
-                ))
+                }
+                _ => {
+                    return Err(ValidationError::InvalidSchema(format!(
+                        "Definition '{}' has unknown type '{}'",
+                        def_name, def_type
+                    )));
+                }
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate a record definition structure
-    fn validate_record_definition(&self, def_name: &str, def_value: &Value) -> Result<(), ValidationError> {
+    fn validate_record_definition(
+        &self,
+        def_name: &str,
+        def_value: &Value,
+    ) -> Result<(), ValidationError> {
         // Record definitions should have a "record" field
-        let record_def = def_value.get("record")
-            .ok_or_else(|| ValidationError::InvalidSchema(
-                format!("Record definition '{}' missing 'record' field", def_name)
-            ))?;
-        
+        let record_def = def_value.get("record").ok_or_else(|| {
+            ValidationError::InvalidSchema(format!(
+                "Record definition '{}' missing 'record' field",
+                def_name
+            ))
+        })?;
+
         // The record field should be an object type
         if record_def.get("type").and_then(|v| v.as_str()) != Some("object") {
-            return Err(ValidationError::InvalidSchema(
-                format!("Record definition '{}' record field must be type 'object'", def_name)
-            ));
+            return Err(ValidationError::InvalidSchema(format!(
+                "Record definition '{}' record field must be type 'object'",
+                def_name
+            )));
         }
-        
+
         // Validate properties if they exist
         if let Some(properties) = record_def.get("properties") {
             if !properties.is_object() {
-                return Err(ValidationError::InvalidSchema(
-                    format!("Record definition '{}' properties must be an object", def_name)
-                ));
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Record definition '{}' properties must be an object",
+                    def_name
+                )));
             }
         }
-        
+
         Ok(())
     }
-    
-    /// Validate an object definition structure  
-    fn validate_object_definition(&self, def_name: &str, def_value: &Value) -> Result<(), ValidationError> {
+
+    /// Validate an object definition structure
+    fn validate_object_definition(
+        &self,
+        def_name: &str,
+        def_value: &Value,
+    ) -> Result<(), ValidationError> {
         // Object definitions should have properties
         if let Some(properties) = def_value.get("properties") {
             if !properties.is_object() {
-                return Err(ValidationError::InvalidSchema(
-                    format!("Object definition '{}' properties must be an object", def_name)
-                ));
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Object definition '{}' properties must be an object",
+                    def_name
+                )));
             }
         }
-        
+
         // Validate required field if it exists
         if let Some(required) = def_value.get("required") {
             if !required.is_array() {
-                return Err(ValidationError::InvalidSchema(
-                    format!("Object definition '{}' required field must be an array", def_name)
-                ));
+                return Err(ValidationError::InvalidSchema(format!(
+                    "Object definition '{}' required field must be an array",
+                    def_name
+                )));
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate that all cross-lexicon references can be resolved within the current lexicon set
     /// This is used before code generation to ensure no missing references
     pub fn validate_lexicon_set_completeness(&self) -> Result<(), String> {
         let mut missing_refs = Vec::new();
-        
+
         for (lexicon_id, lexicon) in &self.lexicons {
             self.collect_missing_references(lexicon_id, &lexicon.defs, &mut missing_refs)?;
         }
-        
+
         if missing_refs.is_empty() {
             Ok(())
         } else {
             Err(missing_refs.join(", "))
         }
     }
-    
+
     /// Recursively collect missing cross-lexicon references
-    fn collect_missing_references(&self, current_lexicon: &str, value: &Value, missing_refs: &mut Vec<String>) -> Result<(), String> {
+    fn collect_missing_references(
+        &self,
+        current_lexicon: &str,
+        value: &Value,
+        missing_refs: &mut Vec<String>,
+    ) -> Result<(), String> {
         match value {
             Value::Object(obj) => {
                 // Check for ref field
···
                             if parts.len() == 2 {
                                 let target_lexicon = parts[0];
                                 if !self.lexicons.contains_key(target_lexicon) {
-                                    let missing_ref = format!("Missing lexicon '{}' (referenced as '{}')", target_lexicon, ref_str);
+                                    let missing_ref = format!(
+                                        "Missing lexicon '{}' (referenced as '{}')",
+                                        target_lexicon, ref_str
+                                    );
                                     if !missing_refs.contains(&missing_ref) {
                                         missing_refs.push(missing_ref);
                                     }
···
                             // Direct lexicon reference without fragment (e.g., app.bsky.richtext.facet)
                             // This references the main definition of another lexicon
                             if !self.lexicons.contains_key(ref_str) {
-                                let missing_ref = format!("Missing lexicon '{}' (referenced as '{}')", ref_str, ref_str);
+                                let missing_ref = format!(
+                                    "Missing lexicon '{}' (referenced as '{}')",
+                                    ref_str, ref_str
+                                );
                                 if !missing_refs.contains(&missing_ref) {
                                     missing_refs.push(missing_ref);
                                 }
···
                         }
                     }
                 }
-                
+
                 // Check for refs array (used in union types)
                 if let Some(refs_array) = obj.get("refs").and_then(|v| v.as_array()) {
                     for ref_value in refs_array {
···
                                     if parts.len() == 2 {
                                         let target_lexicon = parts[0];
                                         if !self.lexicons.contains_key(target_lexicon) {
-                                            let missing_ref = format!("Missing lexicon '{}' (referenced as '{}')", target_lexicon, ref_str);
+                                            let missing_ref = format!(
+                                                "Missing lexicon '{}' (referenced as '{}')",
+                                                target_lexicon, ref_str
+                                            );
                                             if !missing_refs.contains(&missing_ref) {
                                                 missing_refs.push(missing_ref);
                                             }
···
                                 } else if ref_str.contains('.') {
                                     // Direct lexicon reference
                                     if !self.lexicons.contains_key(ref_str) {
-                                        let missing_ref = format!("Missing lexicon '{}' (referenced as '{}')", ref_str, ref_str);
+                                        let missing_ref = format!(
+                                            "Missing lexicon '{}' (referenced as '{}')",
+                                            ref_str, ref_str
+                                        );
                                         if !missing_refs.contains(&missing_ref) {
                                             missing_refs.push(missing_ref);
                                         }
···
                         }
                     }
                 }
-                
+
                 // Recursively check nested objects
                 for (_, nested_value) in obj {
                     self.collect_missing_references(current_lexicon, nested_value, missing_refs)?;
···
                 // Primitive values, nothing to check
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate a value against a schema definition
-    fn validate_value(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
+    fn validate_value(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         let schema_type = schema["type"].as_str().unwrap_or("");
-        
+
         match schema_type {
             "object" => self.validate_object(value, schema, ctx),
             "string" => self.validate_string(value, schema, ctx),
···
             "cid-link" => self.validate_cid_link(value, schema, ctx),
             "unknown" => Ok(()), // Unknown type accepts anything
             "null" => self.validate_null(value, schema, ctx),
-            "" => Err(ValidationError::InvalidSchema(format!("Missing type in schema at {}", ctx.path_string()))),
-            _ => Err(ValidationError::InvalidSchema(format!("Unknown schema type: {} at {}", schema_type, ctx.path_string()))),
+            "" => Err(ValidationError::InvalidSchema(format!(
+                "Missing type in schema at {}",
+                ctx.path_string()
+            ))),
+            _ => Err(ValidationError::InvalidSchema(format!(
+                "Unknown schema type: {} at {}",
+                schema_type,
+                ctx.path_string()
+            ))),
         }
     }
-    
+
     /// Validate an object against an object schema
-    fn validate_object(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        let obj = value.as_object().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "object".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_object(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        let obj = value
+            .as_object()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "object".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // Check required fields
         if let Some(required) = schema["required"].as_array() {
             for req_field in required {
···
                 }
             }
         }
-        
+
         // Validate properties
         if let Some(properties) = schema["properties"].as_object() {
             for (prop_name, prop_schema) in properties {
                 if let Some(prop_value) = obj.get(prop_name) {
                     // Check if field can be null
                     let nullable = if let Some(nullable_fields) = schema["nullable"].as_array() {
-                        nullable_fields.iter().any(|f| f.as_str() == Some(prop_name))
+                        nullable_fields
+                            .iter()
+                            .any(|f| f.as_str() == Some(prop_name))
                     } else {
                         false
                     };
-                    
+
                     if prop_value.is_null() && !nullable {
                         return Err(ValidationError::TypeMismatch {
                             path: ctx.with_field(prop_name).path_string(),
···
                             actual: "null".to_string(),
                         });
                     }
-                    
+
                     if !prop_value.is_null() {
                         self.validate_value(prop_value, prop_schema, &ctx.with_field(prop_name))?;
                     }
                 }
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate a string value
-    fn validate_string(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        let string_val = value.as_str().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "string".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_string(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        let string_val = value
+            .as_str()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "string".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // Check min/max length (in UTF-8 bytes)
         if let Some(min_length) = schema["minLength"].as_u64() {
             if (string_val.len() as u64) < min_length {
                 return Err(ValidationError::StringValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("String length {} is less than minimum {}", string_val.len(), min_length),
+                    message: format!(
+                        "String length {} is less than minimum {}",
+                        string_val.len(),
+                        min_length
+                    ),
                 });
             }
         }
-        
+
         if let Some(max_length) = schema["maxLength"].as_u64() {
             if (string_val.len() as u64) > max_length {
                 return Err(ValidationError::StringValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("String length {} exceeds maximum {}", string_val.len(), max_length),
+                    message: format!(
+                        "String length {} exceeds maximum {}",
+                        string_val.len(),
+                        max_length
+                    ),
                 });
             }
         }
-        
+
         // Check min/max graphemes (simplified grapheme counting)
         if let Some(min_graphemes) = schema["minGraphemes"].as_u64() {
             let grapheme_count = self.count_graphemes(string_val);
             if (grapheme_count as u64) < min_graphemes {
                 return Err(ValidationError::StringValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("String has {} graphemes, less than minimum {}", grapheme_count, min_graphemes),
+                    message: format!(
+                        "String has {} graphemes, less than minimum {}",
+                        grapheme_count, min_graphemes
+                    ),
                 });
             }
         }
-        
+
         if let Some(max_graphemes) = schema["maxGraphemes"].as_u64() {
             let grapheme_count = self.count_graphemes(string_val);
             if (grapheme_count as u64) > max_graphemes {
                 return Err(ValidationError::StringValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("String has {} graphemes, exceeds maximum {}", grapheme_count, max_graphemes),
+                    message: format!(
+                        "String has {} graphemes, exceeds maximum {}",
+                        grapheme_count, max_graphemes
+                    ),
                 });
             }
         }
-        
+
         // Check const value
         if let Some(const_val) = schema["const"].as_str() {
             if string_val != const_val {
···
                 });
             }
         }
-        
+
         // Check enum values
         if let Some(enum_values) = schema["enum"].as_array() {
             let valid = enum_values.iter().any(|v| v.as_str() == Some(string_val));
···
                 });
             }
         }
-        
+
         // Check format
         if let Some(format_str) = schema["format"].as_str() {
             if let Some(format) = StringFormat::from_str(format_str) {
                 self.validate_string_format(string_val, format, ctx)?;
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate string formats
-    fn validate_string_format(&self, value: &str, format: StringFormat, ctx: &ValidationContext) -> Result<(), ValidationError> {
+    fn validate_string_format(
+        &self,
+        value: &str,
+        format: StringFormat,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         match format {
             StringFormat::DateTime => {
                 // Validate RFC3339/ISO8601 datetime
-                DateTime::parse_from_rfc3339(value).map_err(|_| ValidationError::FormatValidationFailed {
-                    path: ctx.path_string(),
-                    format: "datetime".to_string(),
+                DateTime::parse_from_rfc3339(value).map_err(|_| {
+                    ValidationError::FormatValidationFailed {
+                        path: ctx.path_string(),
+                        format: "datetime".to_string(),
+                    }
                 })?;
-            },
+            }
             StringFormat::Uri => {
                 // Basic URI validation - must have scheme followed by colon
                 // Valid schemes include http://, https://, urn:, did:, etc.
···
                         format: "uri".to_string(),
                     });
                 }
-                
+
                 // Check that scheme contains only valid characters
                 let colon_pos = value.find(':').unwrap();
                 let scheme = &value[..colon_pos];
-                if scheme.is_empty() || !scheme.chars().all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '-' || c == '.') {
+                if scheme.is_empty()
+                    || !scheme
+                        .chars()
+                        .all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '-' || c == '.')
+                {
                     return Err(ValidationError::FormatValidationFailed {
                         path: ctx.path_string(),
                         format: "uri".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::AtUri => {
                 // AT-URI format: at://[authority]/[collection]/[rkey]
                 if !value.starts_with("at://") {
···
                         format: "at-uri".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::Did => {
                 // DID format: did:method:identifier
                 if !value.starts_with("did:") {
···
                         format: "did".to_string(),
                     });
                 }
-                
+
                 // Must have at least 3 parts: did:method:identifier
                 let parts: Vec<&str> = value.split(':').collect();
-                if parts.len() < 3 || parts[0] != "did" || parts[1].is_empty() || parts[2].is_empty() {
+                if parts.len() < 3
+                    || parts[0] != "did"
+                    || parts[1].is_empty()
+                    || parts[2].is_empty()
+                {
                     return Err(ValidationError::FormatValidationFailed {
                         path: ctx.path_string(),
                         format: "did".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::Handle => {
                 // Handle format: domain-like (e.g., user.bsky.social)
                 let handle_regex = Regex::new(r"^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$").unwrap();
···
                         format: "handle".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::AtIdentifier => {
                 // Either a DID or a handle (per spec: at-identifier can be either)
                 let is_did = value.starts_with("did:");
-                
-                // Handle format: domain-like (e.g., user.bsky.social) 
+
+                // Handle format: domain-like (e.g., user.bsky.social)
                 let handle_regex = Regex::new(r"^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$").unwrap();
                 let is_handle = handle_regex.is_match(value);
-                
+
                 if !is_did && !is_handle {
                     return Err(ValidationError::FormatValidationFailed {
                         path: ctx.path_string(),
                         format: "at-identifier".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::Nsid => {
                 // NSID format: reversed domain with name (e.g., com.example.foo)
                 let nsid_regex = Regex::new(r"^[a-zA-Z]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$").unwrap();
···
                         format: "nsid".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::Cid => {
                 // Basic CID validation (starts with correct multibase prefix)
-                if !value.starts_with("bafy") && !value.starts_with("bafk") && !value.starts_with("b") {
+                if !value.starts_with("bafy")
+                    && !value.starts_with("bafk")
+                    && !value.starts_with("b")
+                {
                     return Err(ValidationError::FormatValidationFailed {
                         path: ctx.path_string(),
                         format: "cid".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::Tid => {
                 // TID format: timestamp-based identifier (13 chars, base32)
                 let tid_regex = Regex::new(r"^[234567abcdefghijklmnopqrstuvwxyz]{13}$").unwrap();
···
                         format: "tid".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::RecordKey => {
                 // Record key: alphanumeric, dash, underscore, colon, tilde, or TID
                 let rkey_regex = Regex::new(r"^[a-zA-Z0-9._:~-]+$").unwrap();
···
                         format: "record-key".to_string(),
                     });
                 }
-            },
+            }
             StringFormat::Language => {
                 // BCP47 language tag (simplified validation)
                 // Allows for language-region-extension pattern like "en-US-boont"
···
                         format: "language".to_string(),
                     });
                 }
-            },
+            }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate an integer value
-    fn validate_integer(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        let int_val = value.as_i64().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "integer".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_integer(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        let int_val = value
+            .as_i64()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "integer".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         if let Some(minimum) = schema["minimum"].as_i64() {
             if int_val < minimum {
                 return Err(ValidationError::IntegerValidationFailed {
···
                 });
             }
         }
-        
+
         if let Some(maximum) = schema["maximum"].as_i64() {
             if int_val > maximum {
                 return Err(ValidationError::IntegerValidationFailed {
···
                 });
             }
         }
-        
+
         // Check const value
         if let Some(const_val) = schema["const"].as_i64() {
             if int_val != const_val {
···
                 });
             }
         }
-        
+
         if let Some(enum_values) = schema["enum"].as_array() {
             let valid = enum_values.iter().any(|v| v.as_i64() == Some(int_val));
             if !valid {
···
                 });
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate a boolean value
-    fn validate_boolean(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        value.as_bool().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "boolean".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_boolean(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        value
+            .as_bool()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "boolean".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // Check const value if specified
         if let Some(const_val) = schema["const"].as_bool() {
             if value.as_bool() != Some(const_val) {
···
                 });
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate an array
-    fn validate_array(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        let array = value.as_array().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "array".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_array(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        let array = value
+            .as_array()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "array".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // Check min/max length
         if let Some(min_length) = schema["minLength"].as_u64() {
             if (array.len() as u64) < min_length {
                 return Err(ValidationError::ArrayValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("Array length {} is less than minimum {}", array.len(), min_length),
+                    message: format!(
+                        "Array length {} is less than minimum {}",
+                        array.len(),
+                        min_length
+                    ),
                 });
             }
         }
-        
+
         if let Some(max_length) = schema["maxLength"].as_u64() {
             if (array.len() as u64) > max_length {
                 return Err(ValidationError::ArrayValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("Array length {} exceeds maximum {}", array.len(), max_length),
+                    message: format!(
+                        "Array length {} exceeds maximum {}",
+                        array.len(),
+                        max_length
+                    ),
                 });
             }
         }
-        
+
         // Validate items
         if let Some(items_schema) = schema.get("items") {
             for (i, item) in array.iter().enumerate() {
                 self.validate_value(item, items_schema, &ctx.with_index(i))?;
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate a reference
-    fn validate_ref(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
+    fn validate_ref(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         let ref_path = schema["ref"].as_str().ok_or_else(|| {
             ValidationError::InvalidSchema(format!("Missing ref path at {}", ctx.path_string()))
         })?;
-        
+
         // Resolve the reference
         let resolved_schema = self.resolve_ref(ref_path)?;
-        
+
         // Validate against the resolved schema
         self.validate_value(value, &resolved_schema, ctx)
     }
-    
+
     /// Resolve a reference to its schema
     fn resolve_ref(&self, ref_path: &str) -> Result<Value, ValidationError> {
         // Note: Local references need context of which lexicon we're in
···
             // Local reference - would need current lexicon context to resolve
             // For comprehensive testing, we'll implement a basic version
             let fragment = &ref_path[1..]; // Remove the # prefix
-            
+
             // Try to find this fragment in any loaded lexicon (simplified approach)
             for lexicon in self.lexicons.values() {
                 let def = &lexicon.defs[fragment];
···
                     return Ok(def.clone());
                 }
             }
-            
+
             return Err(ValidationError::ReferenceNotFound(ref_path.to_string()));
         }
-        
+
         // Parse NSID#fragment format
         let parts: Vec<&str> = ref_path.split('#').collect();
         let nsid = parts[0];
         let fragment = parts.get(1).map(|s| *s).unwrap_or("main");
-        
-        let lexicon = self.lexicons.get(nsid)
+
+        let lexicon = self
+            .lexicons
+            .get(nsid)
             .ok_or_else(|| ValidationError::ReferenceNotFound(nsid.to_string()))?;
-        
+
         let def = &lexicon.defs[fragment];
         if def.is_null() {
             return Err(ValidationError::ReferenceNotFound(ref_path.to_string()));
         }
-        
+
         Ok(def.clone())
     }
-    
+
     /// Validate a union type
-    fn validate_union(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
+    fn validate_union(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         let refs = schema["refs"].as_array().ok_or_else(|| {
             ValidationError::InvalidSchema(format!("Union missing refs at {}", ctx.path_string()))
         })?;
-        
+
         let is_closed = schema["closed"].as_bool().unwrap_or(false);
-        
+
         // Check if value has $type field
         if let Some(type_field) = value.get("$type").and_then(|v| v.as_str()) {
             // Try to match against the specific type
             for ref_value in refs {
                 if let Some(ref_str) = ref_value.as_str() {
                     // For exact type match, validate against the reference
-                    if ref_str == type_field || ref_str.split('#').next().unwrap_or(ref_str) == type_field {
+                    if ref_str == type_field
+                        || ref_str.split('#').next().unwrap_or(ref_str) == type_field
+                    {
                         return self.validate_ref(value, &serde_json::json!({"ref": ref_str}), ctx);
                     }
                 }
             }
-            
+
             // If this is an open union and we have a $type field, allow unknown types
             if !is_closed {
                 // For open unions, any object with a $type is valid as long as it's structured properly
···
                 }
             }
         }
-        
+
         // Try each variant (fallback for objects without $type or when $type doesn't match)
         for ref_value in refs {
             if let Some(ref_str) = ref_value.as_str() {
···
                 }
             }
         }
-        
+
         Err(ValidationError::UnionValidationFailed {
             path: ctx.path_string(),
         })
     }
-    
+
     /// Validate a blob reference
-    fn validate_blob(&self, value: &Value, _schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        let obj = value.as_object().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "blob object".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_blob(
+        &self,
+        value: &Value,
+        _schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        let obj = value
+            .as_object()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "blob object".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // Check required blob fields
         if !obj.contains_key("$type") || obj["$type"] != "blob" {
             return Err(ValidationError::TypeMismatch {
···
                 actual: format!("{:?}", value),
             });
         }
-        
+
         // Check for ref object with $link
         let ref_obj = obj.get("ref").and_then(|v| v.as_object()).ok_or_else(|| {
             ValidationError::TypeMismatch {
···
                 actual: "missing or invalid".to_string(),
             }
         })?;
-        
+
         if !ref_obj.contains_key("$link") {
             return Err(ValidationError::TypeMismatch {
                 path: ctx.with_field("ref.$link").path_string(),
···
                 actual: "missing".to_string(),
             });
         }
-        
+
         // Check other required fields
         if !obj.contains_key("mimeType") {
             return Err(ValidationError::RequiredFieldMissing {
                 path: ctx.with_field("mimeType").path_string(),
             });
         }
-        
+
         if !obj.contains_key("size") {
             return Err(ValidationError::RequiredFieldMissing {
                 path: ctx.with_field("size").path_string(),
             });
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate bytes type
-    fn validate_bytes(&self, value: &Value, schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
+    fn validate_bytes(
+        &self,
+        value: &Value,
+        schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         // Bytes in JSON are typically base64 encoded strings
-        let string_val = value.as_str().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "bytes (base64 string)".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+        let string_val = value
+            .as_str()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "bytes (base64 string)".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // Basic base64 validation (simplified)
-        if !string_val.chars().all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '/' || c == '=') {
+        if !string_val
+            .chars()
+            .all(|c| c.is_ascii_alphanumeric() || c == '+' || c == '/' || c == '=')
+        {
             return Err(ValidationError::TypeMismatch {
                 path: ctx.path_string(),
                 expected: "valid base64 string".to_string(),
                 actual: "invalid base64".to_string(),
             });
         }
-        
+
         // Check length constraints (bytes length, not string length)
-        let decoded_len = (string_val.len() * 3 / 4) - string_val.chars().filter(|&c| c == '=').count();
-        
+        let decoded_len =
+            (string_val.len() * 3 / 4) - string_val.chars().filter(|&c| c == '=').count();
+
         if let Some(min_length) = schema["minLength"].as_u64() {
             if (decoded_len as u64) < min_length {
                 return Err(ValidationError::StringValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("Bytes length {} is less than minimum {}", decoded_len, min_length),
+                    message: format!(
+                        "Bytes length {} is less than minimum {}",
+                        decoded_len, min_length
+                    ),
                 });
             }
         }
-        
+
         if let Some(max_length) = schema["maxLength"].as_u64() {
             if (decoded_len as u64) > max_length {
                 return Err(ValidationError::StringValidationFailed {
                     path: ctx.path_string(),
-                    message: format!("Bytes length {} exceeds maximum {}", decoded_len, max_length),
+                    message: format!(
+                        "Bytes length {} exceeds maximum {}",
+                        decoded_len, max_length
+                    ),
                 });
             }
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate cid-link type
-    fn validate_cid_link(&self, value: &Value, _schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
-        let obj = value.as_object().ok_or_else(|| ValidationError::TypeMismatch {
-            path: ctx.path_string(),
-            expected: "cid-link object".to_string(),
-            actual: format!("{:?}", value),
-        })?;
-        
+    fn validate_cid_link(
+        &self,
+        value: &Value,
+        _schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
+        let obj = value
+            .as_object()
+            .ok_or_else(|| ValidationError::TypeMismatch {
+                path: ctx.path_string(),
+                expected: "cid-link object".to_string(),
+                actual: format!("{:?}", value),
+            })?;
+
         // CID-link must have $link field with a valid CID
         let link = obj.get("$link").and_then(|v| v.as_str()).ok_or_else(|| {
             ValidationError::RequiredFieldMissing {
                 path: ctx.with_field("$link").path_string(),
             }
         })?;
-        
+
         // Basic CID validation (simplified - should start with appropriate multibase prefix)
-        if !link.starts_with("bafy") && !link.starts_with("bafk") && !link.starts_with("b") && link.len() < 20 {
+        if !link.starts_with("bafy")
+            && !link.starts_with("bafk")
+            && !link.starts_with("b")
+            && link.len() < 20
+        {
             return Err(ValidationError::FormatValidationFailed {
                 path: ctx.with_field("$link").path_string(),
                 format: "cid".to_string(),
             });
         }
-        
+
         Ok(())
     }
-    
+
     /// Validate null type
-    fn validate_null(&self, value: &Value, _schema: &Value, ctx: &ValidationContext) -> Result<(), ValidationError> {
+    fn validate_null(
+        &self,
+        value: &Value,
+        _schema: &Value,
+        ctx: &ValidationContext,
+    ) -> Result<(), ValidationError> {
         if !value.is_null() {
             return Err(ValidationError::TypeMismatch {
                 path: ctx.path_string(),
···
         }
         Ok(())
     }
-    
+
     /// Simplified grapheme counting (approximation)
-    /// This is a basic implementation - for full compliance with TS version, 
+    /// This is a basic implementation - for full compliance with TS version,
     /// would need proper Unicode grapheme cluster segmentation
     fn count_graphemes(&self, s: &str) -> usize {
         // Very simplified approach: count Unicode scalar values, with basic combining character handling
         let mut count = 0;
         let mut chars = s.chars().peekable();
-        
+
         while let Some(_ch) = chars.next() {
             count += 1;
-            
+
             // Skip combining characters that follow this base character
             while let Some(&next_ch) = chars.peek() {
                 if self.is_combining_character(next_ch) {
···
                 }
             }
         }
-        
+
         count
     }
-    
+
     /// Check if a character is a combining character (very simplified)
     fn is_combining_character(&self, ch: char) -> bool {
         // This is a simplified check for common combining marks
         // In a full implementation, would need proper Unicode category checking
-        matches!(ch as u32, 
+        matches!(ch as u32,
             0x0300..=0x036F | // Combining Diacritical Marks
             0x1AB0..=0x1AFF | // Combining Diacritical Marks Extended
             0x1DC0..=0x1DFF | // Combining Diacritical Marks Supplement
···
             0xFE20..=0xFE2F   // Combining Half Marks
         )
     }
-}
+}

api/src/main.rs

···
 use crate::database::Database;
 use crate::errors::AppError;
 use crate::jetstream::JetstreamConsumer;
-use crate::logging::{Logger, LogLevel};
+use crate::logging::{LogLevel, Logger};
 
 #[derive(Clone)]
 pub struct Config {
···
             Logger::global().log_jetstream(
                 LogLevel::Info,
                 "Starting Jetstream consumer",
-                Some(serde_json::json!({"action": "starting_consumer"}))
+                Some(serde_json::json!({"action": "starting_consumer"})),
             );
 
             // Use existing consumer or create new one
···
                     {
                         Ok(consumer) => std::sync::Arc::new(consumer),
                         Err(e) => {
-                            let message = format!("Failed to create Jetstream consumer: {} - will retry in {:?}", e, retry_delay);
+                            let message = format!(
+                                "Failed to create Jetstream consumer: {} - will retry in {:?}",
+                                e, retry_delay
+                            );
                             tracing::error!("{}", message);
                             Logger::global().log_jetstream(
                                 LogLevel::Error,
···
                                     "error": e.to_string(),
                                     "retry_delay_secs": retry_delay.as_secs(),
                                     "action": "consumer_creation_failed"
-                                }))
+                                })),
                             );
                             jetstream_connected_clone
                                 .store(false, std::sync::atomic::Ordering::Relaxed);
···
                                 // No events for 60+ seconds - mark as disconnected
                                 health_check_connected
                                     .store(false, std::sync::atomic::Ordering::Relaxed);
-                                let message = format!("Jetstream marked as disconnected: no events processed in {} seconds", no_events_duration);
+                                let message = format!(
+                                    "Jetstream marked as disconnected: no events processed in {} seconds",
+                                    no_events_duration
+                                );
                                 tracing::warn!("{}", message);
                                 Logger::global().log_jetstream(
                                     LogLevel::Warn,
···
                                     Some(serde_json::json!({
                                         "no_events_duration_secs": no_events_duration,
                                         "action": "health_check_disconnected"
-                                    }))
+                                    })),
                                 );
                             }
                         } else {
···
                             health_check_connected
                                 .store(true, std::sync::atomic::Ordering::Relaxed);
                             if last_count == 0 && current_count > 0 {
-                                let message = "Jetstream health check: events flowing, marked as connected";
+                                let message =
+                                    "Jetstream health check: events flowing, marked as connected";
                                 tracing::info!("{}", message);
                                 Logger::global().log_jetstream(
                                     LogLevel::Info,
···
                                     Some(serde_json::json!({
                                         "event_count": current_count,
                                         "action": "health_check_connected"
-                                    }))
+                                    })),
                                 );
                             }
                         }
···
         )
         // XRPC endpoints
         .route(
-            "/xrpc/social.slices.slice.startSync",
+            "/xrpc/network.slices.slice.startSync",
             post(handler_sync::sync),
         )
         .route(
-            "/xrpc/social.slices.slice.syncUserCollections",
+            "/xrpc/network.slices.slice.syncUserCollections",
             post(handler_sync_user_collections::sync_user_collections),
         )
         .route(
-            "/xrpc/social.slices.slice.getJobStatus",
+            "/xrpc/network.slices.slice.getJobStatus",
             get(handler_jobs::get_job_status),
         )
         .route(
-            "/xrpc/social.slices.slice.getJobHistory",
+            "/xrpc/network.slices.slice.getJobHistory",
             get(handler_jobs::get_slice_job_history),
         )
         .route(
-            "/xrpc/social.slices.slice.getJobLogs",
+            "/xrpc/network.slices.slice.getJobLogs",
             get(handler_logs::get_sync_job_logs_handler),
         )
         .route(
-            "/xrpc/social.slices.slice.getJetstreamLogs",
+            "/xrpc/network.slices.slice.getJetstreamLogs",
             get(handler_logs::get_jetstream_logs_handler),
         )
         .route(
-            "/xrpc/social.slices.slice.stats",
+            "/xrpc/network.slices.slice.stats",
             post(handler_stats::stats),
         )
         .route(
-            "/xrpc/social.slices.slice.getSliceRecords",
+            "/xrpc/network.slices.slice.getSliceRecords",
             post(handler_get_records::get_records),
         )
         .route(
-            "/xrpc/social.slices.slice.codegen",
+            "/xrpc/network.slices.slice.codegen",
             post(handler_xrpc_codegen::generate_client_xrpc),
         )
         .route(
-            "/xrpc/social.slices.slice.openapi",
+            "/xrpc/network.slices.slice.openapi",
             get(handler_openapi_spec::get_openapi_spec),
         )
         .route(
-            "/xrpc/social.slices.slice.getJetstreamStatus",
+            "/xrpc/network.slices.slice.getJetstreamStatus",
             get(handler_jetstream_status::get_jetstream_status),
         )
         .route(
-            "/xrpc/social.slices.slice.getActors",
+            "/xrpc/network.slices.slice.getActors",
             post(handler_get_actors::get_actors),
         )
         // OAuth client management endpoints
         .route(
-            "/xrpc/social.slices.slice.createOAuthClient",
+            "/xrpc/network.slices.slice.createOAuthClient",
             post(handler_oauth_clients::create_oauth_client),
         )
         .route(
-            "/xrpc/social.slices.slice.getOAuthClients",
+            "/xrpc/network.slices.slice.getOAuthClients",
             get(handler_oauth_clients::get_oauth_clients),
         )
         .route(
-            "/xrpc/social.slices.slice.updateOAuthClient",
+            "/xrpc/network.slices.slice.updateOAuthClient",
             post(handler_oauth_clients::update_oauth_client),
         )
         .route(
-            "/xrpc/social.slices.slice.deleteOAuthClient",
+            "/xrpc/network.slices.slice.deleteOAuthClient",
             post(handler_oauth_clients::delete_oauth_client),
         )
         // Dynamic collection-specific XRPC endpoints (wildcard routes must come last)

docs/api-reference.md

···
 
 ## Authentication
 
-Most write operations require OAuth 2.0 authentication. Include the access token in the Authorization header:
+Most write operations require OAuth 2.0 authentication. Include the access token
+in the Authorization header:
 
 ```
 Authorization: Bearer YOUR_ACCESS_TOKEN
···
 
 ### Slice Management
 
-#### `social.slices.slice.listRecords`
+#### `network.slices.slice.listRecords`
 
 List all slices.
 
 **Method**: GET
 
 **Parameters**:
+
 - `limit` (number, optional): Maximum records to return (default: 50)
 - `cursor` (string, optional): Pagination cursor
 - `sort` (string, optional): Sort field and order (e.g., `createdAt:desc`)
···
 - `authors` (string[], optional): Filter by multiple author DIDs
 
 **Response**:
+
 ```json
 {
   "records": [
     {
-      "uri": "at://did:plc:abc/social.slices.slice/xyz",
+      "uri": "at://did:plc:abc/network.slices.slice/xyz",
       "cid": "bafyrei...",
       "did": "did:plc:abc",
-      "collection": "social.slices.slice",
+      "collection": "network.slices.slice",
       "value": {
         "name": "My Slice",
         "domain": "com.example",
···
 }
 ```
 
-#### `social.slices.slice.getRecord`
+#### `network.slices.slice.getRecord`
 
 Get a specific slice by URI.
 
 **Method**: GET
 
 **Parameters**:
+
 - `uri` (string, required): AT Protocol URI of the slice
 
 **Response**: Single record object (same structure as listRecords item)
 
-#### `social.slices.slice.createRecord`
+#### `network.slices.slice.createRecord`
 
 Create a new slice.
 
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
   "record": {
-    "$type": "social.slices.slice",
+    "$type": "network.slices.slice",
     "name": "My New Slice",
     "domain": "com.example",
     "createdAt": "2024-01-01T00:00:00Z"
···
 ```
 
 **Response**:
+
 ```json
 {
-  "uri": "at://did:plc:abc/social.slices.slice/xyz",
+  "uri": "at://did:plc:abc/network.slices.slice/xyz",
   "cid": "bafyrei..."
 }
 ```
 
 ### Slice Operations
 
-#### `social.slices.slice.stats`
+#### `network.slices.slice.stats`
 
 Get statistics for a slice.
 
 **Method**: POST
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri"
···
 ```
 
 **Response**:
+
 ```json
 {
   "success": true,
···
 }
 ```
 
-#### `social.slices.slice.listSliceRecords`
+#### `network.slices.slice.listSliceRecords`
 
 List records across multiple collections in a slice.
 
 **Method**: POST
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
···
 ```
 
 **Response**:
+
 ```json
 {
   "success": true,
···
       "cid": "bafyrei...",
       "did": "did:plc:abc",
       "collection": "com.example.post",
-      "value": { /* record data */ },
+      "value": {/* record data */},
       "indexedAt": "2024-01-01T00:00:00Z"
     }
   ],
···
 }
 ```
 
-#### `social.slices.slice.searchSliceRecords`
+#### `network.slices.slice.searchSliceRecords`
 
 Search records across multiple collections in a slice by content.
 
 **Method**: POST
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
···
 ```
 
 **Response**:
+
 ```json
 {
   "success": true,
···
       "cid": "bafyrei...",
       "did": "did:plc:abc",
       "collection": "com.example.post",
-      "value": { /* record data */ },
+      "value": {/* record data */},
       "indexedAt": "2024-01-01T00:00:00Z"
     }
   ],
···
 }
 ```
 
-#### `social.slices.slice.syncUserCollections`
+#### `network.slices.slice.syncUserCollections`
 
 Synchronously sync collections for the authenticated user.
 
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
···
 ```
 
 **Response**:
+
 ```json
 {
   "success": true,
···
 }
 ```
 
-#### `social.slices.slice.startSync`
+#### `network.slices.slice.startSync`
 
 Start an asynchronous bulk sync job.
 
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
···
 ```
 
 **Response**:
+
 ```json
 {
   "success": true,
···
 }
 ```
 
-#### `social.slices.slice.codegen`
+#### `network.slices.slice.codegen`
 
 Generate TypeScript client code.
 
 **Method**: POST
 
 **Body**:
+
 ```json
 {
   "target": "typescript",
···
 ```
 
 **Response**:
+
 ```json
 {
   "success": true,
···
 
 ## Dynamic Collection Endpoints
 
-For each collection in your slice, the following endpoints are automatically generated:
+For each collection in your slice, the following endpoints are automatically
+generated:
 
 ### `[collection].listRecords`
 
···
 **Method**: GET
 
 **Parameters**:
+
 - `slice` (string, required): Slice URI
 - `limit` (number, optional): Maximum records (default: 50)
 - `cursor` (string, optional): Pagination cursor
···
 **Method**: GET
 
 **Parameters**:
+
 - `slice` (string, required): Slice URI
 - `uri` (string, required): Record URI
 
···
 **Method**: GET
 
 **Parameters**:
+
 - `slice` (string, required): Slice URI
 - `query` (string, required): Search query
 - `field` (string, optional): Specific field to search
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
   "record": {
-    "$type": "collection.name",
+    "$type": "collection.name"
     /* record fields */
   },
   "rkey": "optional-key"
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
   "rkey": "record-key",
   "record": {
-    "$type": "collection.name",
+    "$type": "collection.name"
     /* updated fields */
   }
 }
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "rkey": "record-key"
···
 
 ## Lexicon Management
 
-### `social.slices.lexicon.listRecords`
+### `network.slices.lexicon.listRecords`
 
 List lexicons in a slice.
 
···
 
 **Parameters**: Same as collection.listRecords
 
-### `social.slices.lexicon.createRecord`
+### `network.slices.lexicon.createRecord`
 
 Add a lexicon to a slice.
 
···
 **Authentication**: Required
 
 **Body**:
+
 ```json
 {
   "slice": "at://your-slice-uri",
   "record": {
-    "$type": "social.slices.lexicon",
+    "$type": "network.slices.lexicon",
     "nsid": "com.example.post",
     "definitions": "{\"lexicon\": 1, ...}",
     "createdAt": "2024-01-01T00:00:00Z",
···
 
 ## Actor Management
 
-### `social.slices.slice.getActors`
+### `network.slices.slice.getActors`
 
 Get actors (users) in a slice.
 
 **Method**: GET
 
 **Parameters**:
+
 - `slice` (string, required): Slice URI
 - `search` (string, optional): Search query
 - `dids` (string[], optional): Filter by DIDs
···
 - `cursor` (string, optional): Pagination cursor
 
 **Response**:
+
 ```json
 {
   "actors": [
···
 **Authentication**: Required
 
 **Headers**:
+
 - `Content-Type`: MIME type of the blob
 
 **Body**: Raw binary data
 
 **Response**:
+
 ```json
 {
   "blob": {
···
 ```
 
 Common HTTP status codes:
+
 - `200`: Success
 - `400`: Bad request
 - `401`: Authentication required
···
 3. Continue until no cursor returned
 
 Example:
+
 ```javascript
 let cursor = undefined;
 do {
···
 Sort parameter format: `field:order` or `field1:order1,field2:order2`
 
 Examples:
+
 - `createdAt:desc` - Newest first
 - `name:asc` - Alphabetical
 - `createdAt:desc,name:asc` - Newest first, then alphabetical
···
 
 - [SDK Usage](./sdk-usage.md) - Using generated TypeScript clients
 - [Getting Started](./getting-started.md) - Build your first application
-- [Concepts](./concepts.md) - Understand the architecture
+- [Concepts](./concepts.md) - Understand the architecture

docs/concepts.md

···
 ### Key Properties
 
 - **URI**: Unique AT Protocol URI (e.g.,
-  `at://did:plc:abc123/social.slices.slice/3xyz`)
+  `at://did:plc:abc123/network.slices.slice/3xyz`)
 - **Name**: Human-readable identifier
 - **Domain**: Namespace for lexicons (e.g., `com.example`, `social.grain`)
 - **Creation Date**: When the slice was created
···
 Lexicons follow reverse domain naming:
 
 - `com.example.post` - A post in the example.com namespace
-- `social.slices.slice` - Core slice record type
+- `network.slices.slice` - Core slice record type
 - `app.bsky.actor.profile` - Bluesky profile (external)
 
 ## Collections
···
 
 Built-in endpoints for slice management:
 
-- `social.slices.slice.stats` - Slice statistics
-- `social.slices.slice.records` - Browse records
-- `social.slices.slice.codegen` - Generate SDKs
-- `social.slices.slice.sync` - Trigger sync
+- `network.slices.slice.stats` - Slice statistics
+- `network.slices.slice.records` - Browse records
+- `network.slices.slice.codegen` - Generate SDKs
+- `network.slices.slice.sync` - Trigger sync
 
 ### Handler Authentication
 
···
 
 // Use nested structure matching lexicons
 await client.com.example.post.listRecords();
-await client.social.slices.slice.stats();
+await client.network.slices.slice.stats();
 await client.app.bsky.actor.profile.getRecord({ uri });
 ```
 

docs/getting-started.md

···
 Create `.env` files for both API and frontend:
 
 **API (`/api/.env`)**:
+
 ```bash
 DATABASE_URL=postgres://user:password@localhost:5432/slices
 AUTH_BASE_URL=https://aip.your-domain.com
···
 ```
 
 **Frontend (`/frontend/.env`)**:
+
 ```bash
 OAUTH_CLIENT_ID=your-client-id
 OAUTH_CLIENT_SECRET=your-client-secret
···
 OAUTH_AIP_BASE_URL=https://aip.your-domain.com
 SESSION_ENCRYPTION_KEY=your-32-char-key
 API_URL=http://localhost:3000
-SLICE_URI=at://did:plc:your-did/social.slices.slice/your-slice-id
+SLICE_URI=at://did:plc:your-did/network.slices.slice/your-slice-id
 DATABASE_URL=slices.db
 ```
 
···
 ### 5. Start the Services
 
 Start the API server:
+
 ```bash
 cd api
 cargo run
 ```
 
 Start the frontend:
+
 ```bash
 cd frontend
 deno task dev
···
 ### 2. Create a Slice
 
 Click "Create Slice" and provide:
+
 - **Name**: A friendly name for your slice
 - **Domain**: Your namespace (e.g., `com.example`)
 
 ### 3. Define a Lexicon
 
-Navigate to your slice and go to the Lexicon tab. Create a lexicon for your first record type:
+Navigate to your slice and go to the Lexicon tab. Create a lexicon for your
+first record type:
 
 ```json
 {
···
 
 ### 4. Generate TypeScript Client
 
-Navigate to the Code Generation tab and click "Generate TypeScript Client". This creates a type-safe client library for your slice.
+Navigate to the Code Generation tab and click "Generate TypeScript Client". This
+creates a type-safe client library for your slice.
 
 ### 5. Use the Generated Client
 
···
 import { AtProtoClient } from "./generated-client.ts";
 
 const client = new AtProtoClient(
-  'http://localhost:3000',
-  'at://did:plc:your-did/social.slices.slice/your-slice-id'
+  "http://localhost:3000",
+  "at://did:plc:your-did/network.slices.slice/your-slice-id",
 );
 
 // List posts
···
   title: "My First Post",
   content: "Hello from Slices!",
   createdAt: new Date().toISOString(),
-  tags: ["introduction", "slices"]
+  tags: ["introduction", "slices"],
 });
 
 // Get a specific post
 const post = await client.com.example.post.getRecord({
-  uri: newPost.uri
+  uri: newPost.uri,
 });
 ```
 
···
 ### 2. Configure Sync
 
 Choose collections to sync:
+
 - **Primary Collections**: Your slice's lexicons
 - **External Collections**: Bluesky or other AT Protocol collections
 
 ### 3. Start Sync
 
-Specify repositories (DIDs) to sync from, or leave empty to sync all available data.
+Specify repositories (DIDs) to sync from, or leave empty to sync all available
+data.
 
 ### 4. Monitor Progress
 
···
 ## Troubleshooting
 
 ### Database Connection Issues
+
 - Verify PostgreSQL is running: `docker ps`
 - Check DATABASE_URL format
 - Ensure database exists
 
 ### OAuth Errors
+
 - Verify client ID and secret
 - Check redirect URI matches configuration
 - Ensure AIP server is accessible
 
 ### Sync Not Working
+
 - Check user has necessary permissions
 - Verify lexicons are valid
 - Check API server logs for errors
 
 ### Generated Client Issues
+
 - Regenerate client after lexicon changes
 - Ensure API server is running
-- Check for TypeScript compilation errors
+- Check for TypeScript compilation errors

docs/sdk-usage.md

···
 ```typescript
 const client = new AtProtoClient(
   "https://api.your-domain.com",
-  "at://did:plc:abc/social.slices.slice/your-slice-id",
+  "at://did:plc:abc/network.slices.slice/your-slice-id",
 );
 
 // Read operations work without auth
···
 // Initialize API client with OAuth
 const client = new AtProtoClient(
   "https://api.your-domain.com",
-  "at://did:plc:abc/social.slices.slice/your-slice-id",
+  "at://did:plc:abc/network.slices.slice/your-slice-id",
   oauthClient,
 );
 ```
···
 ### Get Slice Statistics
 
 ```typescript
-const stats = await client.social.slices.slice.stats({
+const stats = await client.network.slices.slice.stats({
   slice: "at://your-slice-uri",
 });
 
···
 
 ```typescript
 // Get all actors in the slice
-const actors = await client.social.slices.slice.getActors();
+const actors = await client.network.slices.slice.getActors();
 
 // With pagination
-const page1 = await client.social.slices.slice.getActors({
+const page1 = await client.network.slices.slice.getActors({
   limit: 20,
 });
-const page2 = await client.social.slices.slice.getActors({
+const page2 = await client.network.slices.slice.getActors({
   limit: 20,
   cursor: page1.cursor,
 });
 
 // Filter by specific DIDs
-const specificActors = await client.social.slices.slice.getActors({
+const specificActors = await client.network.slices.slice.getActors({
   where: {
     did: { in: ["did:plc:user1", "did:plc:user2"] },
   },
 });
 
 // Search by handle
-const searchByHandle = await client.social.slices.slice.getActors({
+const searchByHandle = await client.network.slices.slice.getActors({
   where: {
     handle: { contains: "alice" },
   },
 });
 
 // Filter by exact handle
-const exactHandle = await client.social.slices.slice.getActors({
+const exactHandle = await client.network.slices.slice.getActors({
   where: {
     handle: { eq: "alice.bsky.social" },
   },
···
 
 ```typescript
 // Get records from specific collections
-const records = await client.social.slices.slice.getSliceRecords({
+const records = await client.network.slices.slice.getSliceRecords({
   where: {
     collection: { eq: "com.example.post" },
     did: { eq: "did:plc:specific-author" }, // optional
···
 });
 
 // Search across collections using specific fields
-const searchResults = await client.social.slices.slice.getSliceRecords({
+const searchResults = await client.network.slices.slice.getSliceRecords({
   where: {
     collection: { eq: "com.example.post" },
     title: { contains: "hello world" },
···
 });
 
 // Global search across ALL fields in records
-const globalSearchResults = await client.social.slices.slice.getSliceRecords({
+const globalSearchResults = await client.network.slices.slice.getSliceRecords({
   where: {
     collection: { eq: "com.example.post" },
     json: { contains: "hello world" }, // Searches entire record content
···
 });
 
 // Get records from any collection with global text search
-const allCollectionSearch = await client.social.slices.slice.getSliceRecords({
+const allCollectionSearch = await client.network.slices.slice.getSliceRecords({
   where: {
     json: { contains: "important content" }, // Searches ALL fields in ALL collections
   },
···
 
 ```typescript
 // Search for "tutorial" across all collections
-const crossCollectionSearch = await client.social.slices.slice.getSliceRecords({
-  where: {
-    json: { contains: "tutorial" },
+const crossCollectionSearch = await client.network.slices.slice.getSliceRecords(
+  {
+    where: {
+      json: { contains: "tutorial" },
+    },
   },
-});
+);
 
 // Limit to specific collections
-const specificSearch = await client.social.slices.slice.getSliceRecords({
+const specificSearch = await client.network.slices.slice.getSliceRecords({
   where: {
     collection: { in: ["com.example.post", "com.example.article"] },
     json: { contains: "guide" },
···
 
 ### OR Query Support
 
-You can use OR queries to find records that match any of multiple conditions using the separate `orWhere` parameter. This provides clean type safety and autocomplete for field names:
+You can use OR queries to find records that match any of multiple conditions
+using the separate `orWhere` parameter. This provides clean type safety and
+autocomplete for field names:
 
 ```typescript
 // Find posts by either user1 OR user2
 const posts = await client.com.example.post.getRecords({
   orWhere: {
-    did: { in: ["did:plc:user1", "did:plc:user2"] }
-  }
+    did: { in: ["did:plc:user1", "did:plc:user2"] },
+  },
 });
 
 // Find posts that either have "typescript" in title OR are by a specific user
 const posts = await client.com.example.post.getRecords({
   orWhere: {
     title: { contains: "typescript" },
-    did: { eq: "did:plc:alice" }
-  }
+    did: { eq: "did:plc:alice" },
+  },
 });
 
 // Combining OR with regular AND conditions
 const posts = await client.com.example.post.getRecords({
   where: {
-    createdAt: { eq: "2025-09-03" },  // AND conditions
+    createdAt: { eq: "2025-09-03" }, // AND conditions
   },
-  orWhere: {                          // OR conditions
+  orWhere: { // OR conditions
     title: { contains: "guide" },
-    did: { eq: "did:plc:user1" }
-  }
+    did: { eq: "did:plc:user1" },
+  },
 });
 // SQL: WHERE created_at = '2025-09-03' AND (title LIKE '%guide%' OR did = 'did:plc:user1')
 
 // OR queries work with cross-collection searches too
-const crossCollectionOrSearch = await client.social.slices.slice.getSliceRecords({
-  where: {
-    collection: { eq: "com.example.post" },
-  },
-  orWhere: {
-    title: { contains: "javascript" },
-    tags: { contains: "tutorial" }
-  }
-});
+const crossCollectionOrSearch = await client.network.slices.slice
+  .getSliceRecords({
+    where: {
+      collection: { eq: "com.example.post" },
+    },
+    orWhere: {
+      title: { contains: "javascript" },
+      tags: { contains: "tutorial" },
+    },
+  });
 
 // You get full autocomplete and type safety for field names in both where and orWhere
 const typedSearch = await client.com.example.post.getRecords({
···
     // And also provides autocomplete here
     description: { contains: "tutorial" },
     tags: { contains: "guide" },
-  }
+  },
 });
 ```
 
···
 
 ```typescript
 // Sync current user's data (requires auth)
-const syncResult = await client.social.slices.slice.syncUserCollections({
+const syncResult = await client.network.slices.slice.syncUserCollections({
   timeoutSeconds: 30,
 });
 
···
 const client = new AtProtoClient(apiUrl, sliceUri, oauthClient);
 
 // OAuth tokens are automatically managed
-const profile = await client.social.slices.actor.profile.createRecord({
+const profile = await client.network.slices.actor.profile.createRecord({
   displayName: "New User",
   description: "My profile",
 }, true); // useSelfRkey for profile

frontend/.env.example

···
 OAUTH_REDIRECT_URI="http://localhost:8080/oauth/callback"
 OAUTH_AIP_BASE_URL="https://your-domain.com"
 API_URL="http://localhost:3000"
-SLICE_URI="at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q"
+SLICE_URI="at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z"

frontend/fly.toml

···
   PORT = '8080'
   API_URL = 'https://slices-api.fly.dev'
   DATABASE_URL = '/data/slices.db'
-  SLICE_URI = 'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q'
+  SLICE_URI = 'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z'
   DENO_ENV = 'production'
 
 [http_service]

frontend/src/client.test.ts

···
 
 // Mock fetch function that simulates API responses
 function createMockFetch() {
-  return async (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+  return async (
+    url: string | URL | Request,
+    init?: RequestInit
+  ): Promise<Response> => {
     const requestUrl = url.toString();
     const method = init?.method || "GET";
-    const headers = init?.headers as Record<string, string> || {};
-    
+    const headers = (init?.headers as Record<string, string>) || {};
+
     console.log(`Mock fetch: ${method} ${requestUrl}`);
     console.log(`Authorization header: ${headers["Authorization"] || "none"}`);
-    
+
     // Check if request has valid authorization
-    const hasAuth = headers["Authorization"]?.startsWith("Bearer valid") || 
-                   headers["Authorization"]?.startsWith("Bearer refreshed");
-    
+    const hasAuth =
+      headers["Authorization"]?.startsWith("Bearer valid") ||
+      headers["Authorization"]?.startsWith("Bearer refreshed");
+
     if (method === "GET") {
       // GET requests always succeed (read-only operations)
-      return new Response(JSON.stringify({
-        records: [
-          { uri: "test://uri", cid: "test-cid", value: { name: "Test Record" } }
-        ]
-      }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" }
-      });
+      return new Response(
+        JSON.stringify({
+          records: [
+            {
+              uri: "test://uri",
+              cid: "test-cid",
+              value: { name: "Test Record" },
+            },
+          ],
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        }
+      );
     } else {
       // POST/PUT/DELETE require valid auth
       if (hasAuth) {
-        return new Response(JSON.stringify({
-          uri: "test://created-uri",
-          cid: "test-created-cid"
-        }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" }
-        });
+        return new Response(
+          JSON.stringify({
+            uri: "test://created-uri",
+            cid: "test-created-cid",
+          }),
+          {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          }
+        );
       } else {
-        return new Response(JSON.stringify({
-          error: "Unauthorized"
-        }), {
-          status: 401,
-          headers: { "Content-Type": "application/json" }
-        });
+        return new Response(
+          JSON.stringify({
+            error: "Unauthorized",
+          }),
+          {
+            status: 401,
+            headers: { "Content-Type": "application/json" },
+          }
+        );
       }
     }
   };
···
   const mockOAuth = new MockOAuthClient(tokenState);
   return new AtProtoClient(
     "https://test-api.example.com",
-    "at://did:plc:test/social.slices.slice/test",
+    "at://did:plc:test/network.slices.slice/test",
     mockOAuth as any
   );
 }
···
 Deno.test("Valid tokens - read operation should succeed", async () => {
   // Setup mock fetch
   globalThis.fetch = createMockFetch();
-  
+
   try {
     const client = createTestClient("valid");
-    await client.social.slices.slice.getRecords();
+    await client.network.slices.slice.getRecords();
     console.log("Read operation succeeded as expected");
   } catch (error) {
     throw new Error(`Read operation should have succeeded: ${error}`);
···
 Deno.test("Valid tokens - write operation should succeed", async () => {
   // Setup mock fetch
   globalThis.fetch = createMockFetch();
-  
+
   try {
     const client = createTestClient("valid");
-    await client.social.slices.slice.updateRecord("test", {
+    await client.network.slices.slice.updateRecord("test", {
       name: "Test Slice",
       createdAt: new Date().toISOString(),
     });
···
   async () => {
     // Setup mock fetch
     globalThis.fetch = createMockFetch();
-    
+
     try {
       const client = createTestClient("expired");
-      await client.social.slices.slice.getRecords();
+      await client.network.slices.slice.getRecords();
       console.log("Read operation succeeded after token refresh");
     } catch (error) {
       throw new Error(
···
   async () => {
     // Setup mock fetch
     globalThis.fetch = createMockFetch();
-    
+
     try {
       const client = createTestClient("expired");
-      await client.social.slices.slice.updateRecord("test", {
+      await client.network.slices.slice.updateRecord("test", {
         name: "Test Slice",
         createdAt: new Date().toISOString(),
       });
···
 Deno.test("Token refresh fails - read operation should succeed", async () => {
   // Setup mock fetch
   globalThis.fetch = createMockFetch();
-  
+
   try {
     const client = createTestClient("refresh_fails");
-    await client.social.slices.slice.getRecords();
+    await client.network.slices.slice.getRecords();
     console.log("Read operation succeeded without auth (as expected)");
   } catch (error) {
     throw new Error(
···
   async () => {
     // Setup mock fetch
     globalThis.fetch = createMockFetch();
-    
+
     try {
       const client = createTestClient("refresh_fails");
       await assertRejects(
         async () => {
-          await client.social.slices.slice.updateRecord("test", {
+          await client.network.slices.slice.updateRecord("test", {
             name: "Test Slice",
             createdAt: new Date().toISOString(),
           });
···
 Deno.test("No tokens - read operation should succeed", async () => {
   // Setup mock fetch
   globalThis.fetch = createMockFetch();
-  
+
   try {
     const client = createTestClient("no_tokens");
-    await client.social.slices.slice.getRecords();
+    await client.network.slices.slice.getRecords();
     console.log("Read operation succeeded without tokens (as expected)");
   } catch (error) {
     throw new Error(
···
   async () => {
     // Setup mock fetch
     globalThis.fetch = createMockFetch();
-    
+
     try {
       const client = createTestClient("no_tokens");
       await assertRejects(
         async () => {
-          await client.social.slices.slice.updateRecord("test", {
+          await client.network.slices.slice.updateRecord("test", {
             name: "Test Slice",
             createdAt: new Date().toISOString(),
           });
···
   }
 );
 
-Deno.test(
-  "401 response triggers token refresh and retry",
-  async () => {
-    // Create a fetch that returns 401 first time, 200 second time
-    let callCount = 0;
-    const mockFetch = (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
-      callCount++;
-      const requestUrl = url.toString();
-      const method = init?.method || "GET";
-      const headers = init?.headers as Record<string, string> || {};
-      
-      console.log(`Mock fetch call ${callCount}: ${method} ${requestUrl}`);
-      console.log(`Authorization header: ${headers["Authorization"] || "none"}`);
-      
-      if (method === "POST") {
-        if (callCount === 1) {
-          // First call returns 401
-          console.log("First call - returning 401 Unauthorized");
-          return Promise.resolve(new Response(JSON.stringify({ error: "Unauthorized" }), {
+Deno.test("401 response triggers token refresh and retry", async () => {
+  // Create a fetch that returns 401 first time, 200 second time
+  let callCount = 0;
+  const mockFetch = (
+    url: string | URL | Request,
+    init?: RequestInit
+  ): Promise<Response> => {
+    callCount++;
+    const requestUrl = url.toString();
+    const method = init?.method || "GET";
+    const headers = (init?.headers as Record<string, string>) || {};
+
+    console.log(`Mock fetch call ${callCount}: ${method} ${requestUrl}`);
+    console.log(`Authorization header: ${headers["Authorization"] || "none"}`);
+
+    if (method === "POST") {
+      if (callCount === 1) {
+        // First call returns 401
+        console.log("First call - returning 401 Unauthorized");
+        return Promise.resolve(
+          new Response(JSON.stringify({ error: "Unauthorized" }), {
             status: 401,
-            headers: { "Content-Type": "application/json" }
-          }));
-        } else {
-          // Second call should succeed (with refreshed token)
-          console.log("Second call - returning success");
-          return Promise.resolve(new Response(JSON.stringify({
-            uri: "test://created-uri",
-            cid: "test-created-cid"
-          }), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          }));
-        }
-      }
-      
-      return Promise.resolve(new Response("Not found", { status: 404 }));
-    };
-    
-    globalThis.fetch = mockFetch;
-    
-    try {
-      const client = createTestClient("valid");
-      await client.social.slices.slice.updateRecord("test", {
-        name: "Test Slice",
-        createdAt: new Date().toISOString(),
-      });
-      
-      // Should have made exactly 2 calls
-      console.log(`Total fetch calls made: ${callCount}`);
-      if (callCount !== 2) {
-        throw new Error(`Expected 2 fetch calls but got ${callCount}`);
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      } else {
+        // Second call should succeed (with refreshed token)
+        console.log("Second call - returning success");
+        return Promise.resolve(
+          new Response(
+            JSON.stringify({
+              uri: "test://created-uri",
+              cid: "test-created-cid",
+            }),
+            {
+              status: 200,
+              headers: { "Content-Type": "application/json" },
+            }
+          )
+        );
       }
-      
-      console.log("401 retry test passed - request was retried after token refresh");
-    } finally {
-      // Restore original fetch
-      globalThis.fetch = originalFetch;
+    }
+
+    return Promise.resolve(new Response("Not found", { status: 404 }));
+  };
+
+  globalThis.fetch = mockFetch;
+
+  try {
+    const client = createTestClient("valid");
+    await client.network.slices.slice.updateRecord("test", {
+      name: "Test Slice",
+      createdAt: new Date().toISOString(),
+    });
+
+    // Should have made exactly 2 calls
+    console.log(`Total fetch calls made: ${callCount}`);
+    if (callCount !== 2) {
+      throw new Error(`Expected 2 fetch calls but got ${callCount}`);
     }
+
+    console.log(
+      "401 retry test passed - request was retried after token refresh"
+    );
+  } finally {
+    // Restore original fetch
+    globalThis.fetch = originalFetch;
   }
-);
+});

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-07 23:17:29 UTC
+// Generated at: 2025-09-12 05:27:35 UTC
 // Lexicons: 6
 
 /**
···
  *
  * const client = new AtProtoClient(
  *   'https://slices-api.fly.dev',
- *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lx5zq4t56s2q'
+ *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z'
  * );
  *
  * // Get records from the app.bsky.actor.profile collection
···
  * });
  *
  * // Use slice-level methods for cross-collection queries with type safety
- * const sliceRecords = await client.social.slices.slice.getSliceRecords<AppBskyActorProfile>({
+ * const sliceRecords = await client.network.slices.slice.getSliceRecords<AppBskyActorProfile>({
  *   where: {
  *     collection: { eq: 'app.bsky.actor.profile' }
  *   }
  * });
  *
  * // Search across multiple collections using union types
- * const multiCollectionRecords = await client.social.slices.slice.getSliceRecords<AppBskyActorProfile | AppBskyActorProfile>({
+ * const multiCollectionRecords = await client.network.slices.slice.getSliceRecords<AppBskyActorProfile | AppBskyActorProfile>({
  *   where: {
  *     collection: { in: ['app.bsky.actor.profile', 'app.bsky.actor.profile'] },
  *     text: { contains: 'example search term' },
···
   | "description"
   | "displayName";
 
-export interface SocialSlicesSlice {
+export interface NetworkSlicesSlice {
   /** Name of the slice */
   name: string;
   /** Primary domain namespace for this slice (e.g. social.grain) */
···
   createdAt: string;
 }
 
-export type SocialSlicesSliceSortFields = "name" | "domain" | "createdAt";
+export type NetworkSlicesSliceSortFields = "name" | "domain" | "createdAt";
 
-export interface SocialSlicesLexicon {
+export interface NetworkSlicesLexicon {
   /** Namespaced identifier for the lexicon */
   nsid: string;
   /** The lexicon schema definitions as JSON */
···
   slice: string;
 }
 
-export type SocialSlicesLexiconSortFields =
+export type NetworkSlicesLexiconSortFields =
   | "nsid"
   | "definitions"
   | "createdAt"
   | "updatedAt"
   | "slice";
 
-export interface SocialSlicesActorProfile {
+export interface NetworkSlicesActorProfile {
   displayName?: string;
   /** Free-form profile description text. */
   description?: string;
···
   createdAt?: string;
 }
 
-export type SocialSlicesActorProfileSortFields =
+export type NetworkSlicesActorProfileSortFields =
   | "displayName"
   | "description"
   | "createdAt";
···
   }
 }
 
-class SliceSlicesSocialClient extends BaseClient {
+class SliceSlicesNetworkClient extends BaseClient {
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
···
     limit?: number;
     cursor?: string;
     where?: {
-      [K in SocialSlicesSliceSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | NetworkSlicesSliceSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
-      [K in SocialSlicesSliceSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | NetworkSlicesSliceSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<SocialSlicesSliceSortFields>[];
-  }): Promise<GetRecordsResponse<SocialSlicesSlice>> {
+    sortBy?: SortField<NetworkSlicesSliceSortFields>[];
+  }): Promise<GetRecordsResponse<NetworkSlicesSlice>> {
     // Combine where and orWhere into the expected backend format
     const whereClause: any = params?.where ? { ...params.where } : {};
     if (params?.orWhere) {
···
       slice: this.sliceUri,
     };
     const result = await this.makeRequest<SliceRecordsOutput>(
-      "social.slices.slice.getRecords",
+      "network.slices.slice.getRecords",
       "POST",
       requestParams
     );
···
         cid: record.cid,
         did: record.did,
         collection: record.collection,
-        value: record.value as unknown as SocialSlicesSlice,
+        value: record.value as unknown as NetworkSlicesSlice,
         indexedAt: record.indexedAt,
       })),
       cursor: result.cursor,
···
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<SocialSlicesSlice>> {
+  ): Promise<RecordResponse<NetworkSlicesSlice>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<SocialSlicesSlice>>(
-      "social.slices.slice.getRecord",
+    return await this.makeRequest<RecordResponse<NetworkSlicesSlice>>(
+      "network.slices.slice.getRecord",
       "GET",
       requestParams
     );
···
     limit?: number;
     cursor?: string;
     where?: {
-      [K in SocialSlicesSliceSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | NetworkSlicesSliceSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
-      [K in SocialSlicesSliceSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | NetworkSlicesSliceSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<SocialSlicesSliceSortFields>[];
+    sortBy?: SortField<NetworkSlicesSliceSortFields>[];
   }): Promise<CountRecordsResponse> {
     // Combine where and orWhere into the expected backend format
     const whereClause: any = params?.where ? { ...params.where } : {};
···
       slice: this.sliceUri,
     };
     return await this.makeRequest<CountRecordsResponse>(
-      "social.slices.slice.countRecords",
+      "network.slices.slice.countRecords",
       "POST",
       requestParams
     );
   }
 
   async createRecord(
-    record: SocialSlicesSlice,
+    record: NetworkSlicesSlice,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.slice", ...record };
+    const recordValue = { $type: "network.slices.slice", ...record };
     const payload = {
       slice: this.sliceUri,
       ...(useSelfRkey ? { rkey: "self" } : {}),
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.slice.createRecord",
+      "network.slices.slice.createRecord",
       "POST",
       payload
     );
···
 
   async updateRecord(
     rkey: string,
-    record: SocialSlicesSlice
+    record: NetworkSlicesSlice
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.slice", ...record };
+    const recordValue = { $type: "network.slices.slice", ...record };
     const payload = {
       slice: this.sliceUri,
       rkey,
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.slice.updateRecord",
+      "network.slices.slice.updateRecord",
       "POST",
       payload
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.makeRequest<void>(
-      "social.slices.slice.deleteRecord",
+      "network.slices.slice.deleteRecord",
       "POST",
       { rkey }
     );
···
 
   async codegen(request: CodegenXrpcRequest): Promise<CodegenXrpcResponse> {
     return await this.makeRequest<CodegenXrpcResponse>(
-      "social.slices.slice.codegen",
+      "network.slices.slice.codegen",
       "POST",
       request
     );
···
 
   async stats(params: SliceStatsParams): Promise<SliceStatsOutput> {
     return await this.makeRequest<SliceStatsOutput>(
-      "social.slices.slice.stats",
+      "network.slices.slice.stats",
       "POST",
       params
     );
···
       slice: this.sliceUri,
     };
     return await this.makeRequest<SliceRecordsOutput<T>>(
-      "social.slices.slice.getSliceRecords",
+      "network.slices.slice.getSliceRecords",
       "POST",
       requestParams
     );
···
   async getActors(params?: GetActorsParams): Promise<GetActorsResponse> {
     const requestParams = { ...params, slice: this.sliceUri };
     return await this.makeRequest<GetActorsResponse>(
-      "social.slices.slice.getActors",
+      "network.slices.slice.getActors",
       "POST",
       requestParams
     );
···
   async startSync(params: BulkSyncParams): Promise<SyncJobResponse> {
     const requestParams = { ...params, slice: this.sliceUri };
     return await this.makeRequest<SyncJobResponse>(
-      "social.slices.slice.startSync",
+      "network.slices.slice.startSync",
       "POST",
       requestParams
     );
···
 
   async getJobStatus(params: GetJobStatusParams): Promise<JobStatus> {
     return await this.makeRequest<JobStatus>(
-      "social.slices.slice.getJobStatus",
+      "network.slices.slice.getJobStatus",
       "GET",
       params
     );
···
     params: GetJobHistoryParams
   ): Promise<GetJobHistoryResponse> {
     return await this.makeRequest<GetJobHistoryResponse>(
-      "social.slices.slice.getJobHistory",
+      "network.slices.slice.getJobHistory",
       "GET",
       params
     );
···
 
   async getJobLogs(params: GetJobLogsParams): Promise<GetJobLogsResponse> {
     return await this.makeRequest<GetJobLogsResponse>(
-      "social.slices.slice.getJobLogs",
+      "network.slices.slice.getJobLogs",
       "GET",
       params
     );
···
 
   async getJetstreamStatus(): Promise<JetstreamStatusResponse> {
     return await this.makeRequest<JetstreamStatusResponse>(
-      "social.slices.slice.getJetstreamStatus",
+      "network.slices.slice.getJetstreamStatus",
       "GET"
     );
   }
···
     params: GetJetstreamLogsParams
   ): Promise<GetJetstreamLogsResponse> {
     return await this.makeRequest<GetJetstreamLogsResponse>(
-      "social.slices.slice.getJetstreamLogs",
+      "network.slices.slice.getJetstreamLogs",
       "GET",
       params
     );
···
   ): Promise<SyncUserCollectionsResult> {
     const requestParams = { slice: this.sliceUri, ...params };
     return await this.makeRequest<SyncUserCollectionsResult>(
-      "social.slices.slice.syncUserCollections",
+      "network.slices.slice.syncUserCollections",
       "POST",
       requestParams
     );
···
   ): Promise<OAuthClientDetails> {
     const requestParams = { ...params, sliceUri: this.sliceUri };
     return await this.makeRequest<OAuthClientDetails>(
-      "social.slices.slice.createOAuthClient",
+      "network.slices.slice.createOAuthClient",
       "POST",
       requestParams
     );
···
   async getOAuthClients(): Promise<ListOAuthClientsResponse> {
     const requestParams = { slice: this.sliceUri };
     return await this.makeRequest<ListOAuthClientsResponse>(
-      "social.slices.slice.getOAuthClients",
+      "network.slices.slice.getOAuthClients",
       "GET",
       requestParams
     );
···
   ): Promise<OAuthClientDetails> {
     const requestParams = { ...params, sliceUri: this.sliceUri };
     return await this.makeRequest<OAuthClientDetails>(
-      "social.slices.slice.updateOAuthClient",
+      "network.slices.slice.updateOAuthClient",
       "POST",
       requestParams
     );
···
     clientId: string
   ): Promise<DeleteOAuthClientResponse> {
     return await this.makeRequest<DeleteOAuthClientResponse>(
-      "social.slices.slice.deleteOAuthClient",
+      "network.slices.slice.deleteOAuthClient",
       "POST",
       { clientId }
     );
   }
 }
 
-class LexiconSlicesSocialClient extends BaseClient {
+class LexiconSlicesNetworkClient extends BaseClient {
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
···
     cursor?: string;
     where?: {
       [K in
-        | SocialSlicesLexiconSortFields
+        | NetworkSlicesLexiconSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
       [K in
-        | SocialSlicesLexiconSortFields
+        | NetworkSlicesLexiconSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<SocialSlicesLexiconSortFields>[];
-  }): Promise<GetRecordsResponse<SocialSlicesLexicon>> {
+    sortBy?: SortField<NetworkSlicesLexiconSortFields>[];
+  }): Promise<GetRecordsResponse<NetworkSlicesLexicon>> {
     // Combine where and orWhere into the expected backend format
     const whereClause: any = params?.where ? { ...params.where } : {};
     if (params?.orWhere) {
···
       slice: this.sliceUri,
     };
     const result = await this.makeRequest<SliceRecordsOutput>(
-      "social.slices.lexicon.getRecords",
+      "network.slices.lexicon.getRecords",
       "POST",
       requestParams
     );
···
         cid: record.cid,
         did: record.did,
         collection: record.collection,
-        value: record.value as unknown as SocialSlicesLexicon,
+        value: record.value as unknown as NetworkSlicesLexicon,
         indexedAt: record.indexedAt,
       })),
       cursor: result.cursor,
···
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<SocialSlicesLexicon>> {
+  ): Promise<RecordResponse<NetworkSlicesLexicon>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<SocialSlicesLexicon>>(
-      "social.slices.lexicon.getRecord",
+    return await this.makeRequest<RecordResponse<NetworkSlicesLexicon>>(
+      "network.slices.lexicon.getRecord",
       "GET",
       requestParams
     );
···
     cursor?: string;
     where?: {
       [K in
-        | SocialSlicesLexiconSortFields
+        | NetworkSlicesLexiconSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
       [K in
-        | SocialSlicesLexiconSortFields
+        | NetworkSlicesLexiconSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<SocialSlicesLexiconSortFields>[];
+    sortBy?: SortField<NetworkSlicesLexiconSortFields>[];
   }): Promise<CountRecordsResponse> {
     // Combine where and orWhere into the expected backend format
     const whereClause: any = params?.where ? { ...params.where } : {};
···
       slice: this.sliceUri,
     };
     return await this.makeRequest<CountRecordsResponse>(
-      "social.slices.lexicon.countRecords",
+      "network.slices.lexicon.countRecords",
       "POST",
       requestParams
     );
   }
 
   async createRecord(
-    record: SocialSlicesLexicon,
+    record: NetworkSlicesLexicon,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.lexicon", ...record };
+    const recordValue = { $type: "network.slices.lexicon", ...record };
     const payload = {
       slice: this.sliceUri,
       ...(useSelfRkey ? { rkey: "self" } : {}),
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.lexicon.createRecord",
+      "network.slices.lexicon.createRecord",
       "POST",
       payload
     );
···
 
   async updateRecord(
     rkey: string,
-    record: SocialSlicesLexicon
+    record: NetworkSlicesLexicon
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.lexicon", ...record };
+    const recordValue = { $type: "network.slices.lexicon", ...record };
     const payload = {
       slice: this.sliceUri,
       rkey,
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.lexicon.updateRecord",
+      "network.slices.lexicon.updateRecord",
       "POST",
       payload
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.makeRequest<void>(
-      "social.slices.lexicon.deleteRecord",
+      "network.slices.lexicon.deleteRecord",
       "POST",
       { rkey }
     );
   }
 }
 
-class ProfileActorSlicesSocialClient extends BaseClient {
+class ProfileActorSlicesNetworkClient extends BaseClient {
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
···
     cursor?: string;
     where?: {
       [K in
-        | SocialSlicesActorProfileSortFields
+        | NetworkSlicesActorProfileSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
       [K in
-        | SocialSlicesActorProfileSortFields
+        | NetworkSlicesActorProfileSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<SocialSlicesActorProfileSortFields>[];
-  }): Promise<GetRecordsResponse<SocialSlicesActorProfile>> {
+    sortBy?: SortField<NetworkSlicesActorProfileSortFields>[];
+  }): Promise<GetRecordsResponse<NetworkSlicesActorProfile>> {
     // Combine where and orWhere into the expected backend format
     const whereClause: any = params?.where ? { ...params.where } : {};
     if (params?.orWhere) {
···
       slice: this.sliceUri,
     };
     const result = await this.makeRequest<SliceRecordsOutput>(
-      "social.slices.actor.profile.getRecords",
+      "network.slices.actor.profile.getRecords",
       "POST",
       requestParams
     );
···
         cid: record.cid,
         did: record.did,
         collection: record.collection,
-        value: record.value as unknown as SocialSlicesActorProfile,
+        value: record.value as unknown as NetworkSlicesActorProfile,
         indexedAt: record.indexedAt,
       })),
       cursor: result.cursor,
···
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<SocialSlicesActorProfile>> {
+  ): Promise<RecordResponse<NetworkSlicesActorProfile>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<SocialSlicesActorProfile>>(
-      "social.slices.actor.profile.getRecord",
+    return await this.makeRequest<RecordResponse<NetworkSlicesActorProfile>>(
+      "network.slices.actor.profile.getRecord",
       "GET",
       requestParams
     );
···
     cursor?: string;
     where?: {
       [K in
-        | SocialSlicesActorProfileSortFields
+        | NetworkSlicesActorProfileSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
       [K in
-        | SocialSlicesActorProfileSortFields
+        | NetworkSlicesActorProfileSortFields
         | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<SocialSlicesActorProfileSortFields>[];
+    sortBy?: SortField<NetworkSlicesActorProfileSortFields>[];
   }): Promise<CountRecordsResponse> {
     // Combine where and orWhere into the expected backend format
     const whereClause: any = params?.where ? { ...params.where } : {};
···
       slice: this.sliceUri,
     };
     return await this.makeRequest<CountRecordsResponse>(
-      "social.slices.actor.profile.countRecords",
+      "network.slices.actor.profile.countRecords",
       "POST",
       requestParams
     );
   }
 
   async createRecord(
-    record: SocialSlicesActorProfile,
+    record: NetworkSlicesActorProfile,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.actor.profile", ...record };
+    const recordValue = { $type: "network.slices.actor.profile", ...record };
     const payload = {
       slice: this.sliceUri,
       ...(useSelfRkey ? { rkey: "self" } : {}),
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.actor.profile.createRecord",
+      "network.slices.actor.profile.createRecord",
       "POST",
       payload
     );
···
 
   async updateRecord(
     rkey: string,
-    record: SocialSlicesActorProfile
+    record: NetworkSlicesActorProfile
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.actor.profile", ...record };
+    const recordValue = { $type: "network.slices.actor.profile", ...record };
     const payload = {
       slice: this.sliceUri,
       rkey,
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.actor.profile.updateRecord",
+      "network.slices.actor.profile.updateRecord",
       "POST",
       payload
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.makeRequest<void>(
-      "social.slices.actor.profile.deleteRecord",
+      "network.slices.actor.profile.deleteRecord",
       "POST",
       { rkey }
     );
   }
 }
 
-class ActorSlicesSocialClient extends BaseClient {
-  readonly profile: ProfileActorSlicesSocialClient;
+class ActorSlicesNetworkClient extends BaseClient {
+  readonly profile: ProfileActorSlicesNetworkClient;
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
     super(baseUrl, oauthClient);
     this.sliceUri = sliceUri;
-    this.profile = new ProfileActorSlicesSocialClient(
+    this.profile = new ProfileActorSlicesNetworkClient(
       baseUrl,
       sliceUri,
       oauthClient
···
   }
 }
 
-class SlicesSocialClient extends BaseClient {
-  readonly slice: SliceSlicesSocialClient;
-  readonly lexicon: LexiconSlicesSocialClient;
-  readonly actor: ActorSlicesSocialClient;
+class SlicesNetworkClient extends BaseClient {
+  readonly slice: SliceSlicesNetworkClient;
+  readonly lexicon: LexiconSlicesNetworkClient;
+  readonly actor: ActorSlicesNetworkClient;
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
     super(baseUrl, oauthClient);
     this.sliceUri = sliceUri;
-    this.slice = new SliceSlicesSocialClient(baseUrl, sliceUri, oauthClient);
-    this.lexicon = new LexiconSlicesSocialClient(
+    this.slice = new SliceSlicesNetworkClient(baseUrl, sliceUri, oauthClient);
+    this.lexicon = new LexiconSlicesNetworkClient(
       baseUrl,
       sliceUri,
       oauthClient
     );
-    this.actor = new ActorSlicesSocialClient(baseUrl, sliceUri, oauthClient);
+    this.actor = new ActorSlicesNetworkClient(baseUrl, sliceUri, oauthClient);
   }
 }
 
-class SocialClient extends BaseClient {
-  readonly slices: SlicesSocialClient;
+class NetworkClient extends BaseClient {
+  readonly slices: SlicesNetworkClient;
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
     super(baseUrl, oauthClient);
     this.sliceUri = sliceUri;
-    this.slices = new SlicesSocialClient(baseUrl, sliceUri, oauthClient);
+    this.slices = new SlicesNetworkClient(baseUrl, sliceUri, oauthClient);
   }
 }
 
 export class AtProtoClient extends BaseClient {
   readonly app: AppClient;
-  readonly social: SocialClient;
+  readonly network: NetworkClient;
   readonly oauth?: OAuthClient;
   private readonly sliceUri: string;
 
···
     super(baseUrl, oauthClient);
     this.sliceUri = sliceUri;
     this.app = new AppClient(baseUrl, sliceUri, oauthClient);
-    this.social = new SocialClient(baseUrl, sliceUri, oauthClient);
+    this.network = new NetworkClient(baseUrl, sliceUri, oauthClient);
     this.oauth = this.oauthClient;
   }
 
   async getActors(params: GetActorsParams): Promise<GetActorsResponse> {
     const requestParams = { ...params, slice: this.sliceUri };
     return await this.makeRequest<GetActorsResponse>(
-      "social.slices.slice.getActors",
+      "network.slices.slice.getActors",
       "POST",
       requestParams
     );
···
       slice: this.sliceUri,
     };
     return await this.makeRequest<SliceRecordsOutput<T>>(
-      "social.slices.slice.getSliceRecords",
+      "network.slices.slice.getSliceRecords",
       "POST",
       requestParams
     );

frontend/src/features/auth/handlers.tsx

···
           // If we can't find existing records, sync them
           if (!profileCheck.records || profileCheck.records.length === 0) {
             console.log("No existing external collections found, syncing...");
-            await atprotoClient.social.slices.slice.syncUserCollections();
+            await atprotoClient.network.slices.slice.syncUserCollections();
           } else {
             console.log("External collections already synced, skipping sync");
           }

frontend/src/features/dashboard/handlers.tsx

···
   id: string;
 }
 
-async function handleProfilePage(req: Request, params?: URLPatternResult): Promise<Response> {
+async function handleProfilePage(
+  req: Request,
+  params?: URLPatternResult
+): Promise<Response> {
   const context = await withAuth(req);
   const authResponse = requireAuth(context);
   if (authResponse) return authResponse;
···
   let profileDid: string;
   try {
     const actors = await atprotoClient.getActors({
-      where: { handle: { eq: handle } }
+      where: { handle: { eq: handle } },
     });
-    
+
     if (actors.actors.length === 0) {
       return new Response("Profile not found", { status: 404 });
     }
-    
+
     profileDid = actors.actors[0].did;
   } catch (error) {
     console.error("Failed to get actor:", error);
···
   // Fetch profile record using the DID
   let _profileRecord;
   try {
-    const profileResponse = await atprotoClient.app.bsky.actor.profile.getRecords({
-      where: { did: { eq: profileDid } }
-    });
+    const profileResponse =
+      await atprotoClient.app.bsky.actor.profile.getRecords({
+        where: { did: { eq: profileDid } },
+      });
     _profileRecord = profileResponse.records[0];
   } catch (error) {
     console.error("Failed to fetch profile:", error);
···
 
   try {
     // Fetch slices for this DID
-    const sliceRecords = await atprotoClient.social.slices.slice.getRecords({
+    const sliceRecords = await atprotoClient.network.slices.slice.getRecords({
       where: { did: { eq: profileDid } },
       sortBy: [{ field: "createdAt", direction: "desc" }],
     });
···
         createdAt: new Date().toISOString(),
       };
 
-      const result = await atprotoClient.social.slices.slice.createRecord(
+      const result = await atprotoClient.network.slices.slice.createRecord(
         recordData
       );
 
···
       );
     }
   } catch (_error) {
-    return renderHTML(
-      <CreateSliceDialog error="Failed to create slice" />
-    );
+    return renderHTML(<CreateSliceDialog error="Failed to create slice" />);
   }
 }
 
···
     pattern: new URLPattern({ pathname: "/dialogs/create-slice" }),
     handler: handleCreateSliceDialog,
   },
-];
+];

frontend/src/features/settings/handlers.tsx

···
 
   try {
     const profileRecord =
-      await atprotoClient.social.slices.actor.profile.getRecord({
+      await atprotoClient.network.slices.actor.profile.getRecord({
         uri: buildAtUri({
           did: context.currentUser.sub!,
-          collection: "social.slices.actor.profile",
+          collection: "network.slices.actor.profile",
           rkey: "self",
         }),
       });
···
   }
 
   return renderHTML(
-    <SettingsPage 
-      profile={profile} 
+    <SettingsPage
+      profile={profile}
       currentUser={context.currentUser}
       updated={updated === "true"}
       error={error}
···
       }
 
       const existingProfile =
-        await atprotoClient.social.slices.actor.profile.getRecord({
+        await atprotoClient.network.slices.actor.profile.getRecord({
           uri: buildAtUri({
             did: context.currentUser.sub,
-            collection: "social.slices.actor.profile",
+            collection: "network.slices.actor.profile",
             rkey: "self",
           }),
         });
 
       if (existingProfile) {
-        await atprotoClient.social.slices.actor.profile.updateRecord("self", {
+        await atprotoClient.network.slices.actor.profile.updateRecord("self", {
           ...profileData,
           createdAt: existingProfile.value.createdAt,
         });
       } else {
-        await atprotoClient.social.slices.actor.profile.createRecord(
+        await atprotoClient.network.slices.actor.profile.createRecord(
           profileData,
           true
         );
···
     pattern: new URLPattern({ pathname: "/api/profile" }),
     handler: handleUpdateProfile,
   },
-];
+];

frontend/src/features/slices/api-docs/handlers.tsx

···
     try {
       const sliceUri = buildAtUri({
         did: context.currentUser.sub!,
-        collection: "social.slices.slice",
+        collection: "network.slices.slice",
         rkey: sliceId,
       });
 
-      const sliceRecord = await atprotoClient.social.slices.slice.getRecord({
+      const sliceRecord = await atprotoClient.network.slices.slice.getRecord({
         uri: sliceUri,
       });
 
···
     pattern: new URLPattern({ pathname: "/slices/:id/api-docs" }),
     handler: handleSliceApiDocsPage,
   },
-];
+];

frontend/src/features/slices/api-docs/templates/SliceApiDocsPage.tsx

···
   const baseUrl = Deno.env.get("API_URL") || "http://localhost:3000";
 
   // Build the slice URI
-  const sliceUri = `at://${currentUser.sub}/social.slices.slice/${sliceId}`;
-  const openApiUrl = `${baseUrl}/xrpc/social.slices.slice.openapi?slice=${encodeURIComponent(
+  const sliceUri = `at://${currentUser.sub}/network.slices.slice/${sliceId}`;
+  const openApiUrl = `${baseUrl}/xrpc/network.slices.slice.openapi?slice=${encodeURIComponent(
     sliceUri
   )}`;
 
···
         <script src="https://cdn.tailwindcss.com"></script>
       </head>
       <body class="bg-gray-50 min-h-screen">
-      {/* Header with back button */}
-      <div class="bg-white border-b border-gray-200 px-4 py-4">
-        <div class="max-w-7xl mx-auto flex items-center justify-between">
-          <div class="flex items-center">
-            <a
-              href={`/slices/${sliceId}`}
-              class="text-blue-600 hover:text-blue-800 mr-4 flex items-center"
-            >
-              <svg
-                class="w-4 h-4 mr-1"
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
+        {/* Header with back button */}
+        <div class="bg-white border-b border-gray-200 px-4 py-4">
+          <div class="max-w-7xl mx-auto flex items-center justify-between">
+            <div class="flex items-center">
+              <a
+                href={`/slices/${sliceId}`}
+                class="text-blue-600 hover:text-blue-800 mr-4 flex items-center"
               >
-                <path
-                  stroke-linecap="round"
-                  stroke-linejoin="round"
-                  stroke-width="2"
-                  d="M15 19l-7-7 7-7"
-                />
-              </svg>
-              Back to {sliceName}
-            </a>
-          </div>
-          <div class="text-right">
-            <h1 class="text-xl font-semibold text-gray-900">API Documentation</h1>
-            <p class="text-gray-600 text-sm">
-              Interactive OpenAPI docs for your slice
-            </p>
+                <svg
+                  class="w-4 h-4 mr-1"
+                  fill="none"
+                  stroke="currentColor"
+                  viewBox="0 0 24 24"
+                >
+                  <path
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="2"
+                    d="M15 19l-7-7 7-7"
+                  />
+                </svg>
+                Back to {sliceName}
+              </a>
+            </div>
+            <div class="text-right">
+              <h1 class="text-xl font-semibold text-gray-900">
+                API Documentation
+              </h1>
+              <p class="text-gray-600 text-sm">
+                Interactive OpenAPI docs for your slice
+              </p>
+            </div>
           </div>
         </div>
-      </div>
 
         {/* Info bar */}
         <div class="bg-blue-50 border-b border-blue-200 px-4 py-3">
···
           </div>
         </div>
 
-      {/* Load Scalar API Reference */}
-      <script
-        src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"
-        async
-      ></script>
+        {/* Load Scalar API Reference */}
+        <script
+          src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"
+          async
+        ></script>
 
-      {/* Initialize Scalar when the script loads */}
-      <script
-        dangerouslySetInnerHTML={{
-          __html: `
+        {/* Initialize Scalar when the script loads */}
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `
             document.addEventListener('DOMContentLoaded', function() {
               // Wait for Scalar to be available
               const initScalar = () => {
···
                       // Alternative approach for parameter defaults
                       defaultParameters: {
                         slice: '${sliceUri}'
-                      },${accessToken ? `
+                      },${
+                        accessToken
+                          ? `
                       authentication: {
                         preferredSecurityScheme: 'bearerAuth',
                         http: {
···
                             token: '${accessToken}'
                           }
                         }
-                      },` : ''}
+                      },`
+                          : ""
+                      }
                       customCss: \`
                         .scalar-api-reference {
                           width: 100% !important;
···
               initScalar();
             });
           `,
-        }}
-      />
+          }}
+        />
       </body>
     </html>
   );
-}
+}

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

···
 
   try {
     const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
-    const slice = await atprotoClient.social.slices.slice.getRecord({
+    const slice = await atprotoClient.network.slices.slice.getRecord({
       uri: sliceUri,
     });
 
···
     const sliceClient = getSliceClient(context, sliceId);
 
     // Call the codegen XRPC endpoint
-    const result = await sliceClient.social.slices.slice.codegen({
+    const result = await sliceClient.network.slices.slice.codegen({
       target: target as string,
       slice: sliceUri,
     });

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

···
     const sliceClient = getSliceClient(context, sliceId);
 
     // Get Jetstream logs
-    const result = await sliceClient.social.slices.slice.getJetstreamLogs({
+    const result = await sliceClient.network.slices.slice.getJetstreamLogs({
       limit: 100,
     });
 
···
     const isCompact = url.searchParams.get("compact") === "true";
 
     // Fetch jetstream status using the atproto client
-    const data = await atprotoClient.social.slices.slice.getJetstreamStatus();
+    const data = await atprotoClient.network.slices.slice.getJetstreamStatus();
 
     // Render compact version for logs page
     if (isCompact) {
···
   try {
     const sliceClient = getSliceClient(context, sliceId);
 
-    const logsResult = await sliceClient.social.slices.slice.getJetstreamLogs({
+    const logsResult = await sliceClient.network.slices.slice.getJetstreamLogs({
       limit: 100,
     });
     logs = logsResult.logs.sort(
···
     pattern: new URLPattern({ pathname: "/api/slices/:id/jetstream/logs" }),
     handler: handleJetstreamLogs,
   },
-];
+];

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

···
 
   try {
     const sliceClient = getSliceClient(context, sliceId);
-    const lexiconRecords = await sliceClient.social.slices.lexicon.getRecords();
+    const lexiconRecords =
+      await sliceClient.network.slices.lexicon.getRecords();
 
     if (lexiconRecords.records.length === 0) {
       return renderHTML(<EmptyLexiconState />);
···
       };
 
       const sliceClient = getSliceClient(context, sliceId);
-      const result = await sliceClient.social.slices.lexicon.createRecord(
+      const result = await sliceClient.network.slices.lexicon.createRecord(
         lexiconRecord
       );
 
···
 
   try {
     const sliceClient = getSliceClient(context, sliceId);
-    const lexiconRecords = await sliceClient.social.slices.lexicon.getRecords();
+    const lexiconRecords =
+      await sliceClient.network.slices.lexicon.getRecords();
 
     const lexicon = lexiconRecords.records.find((record) =>
       record.uri.endsWith(`/${rkey}`)
···
 
   try {
     const sliceClient = getSliceClient(context, sliceId);
-    await sliceClient.social.slices.lexicon.deleteRecord(rkey);
+    await sliceClient.network.slices.lexicon.deleteRecord(rkey);
 
     const remainingLexicons =
-      await sliceClient.social.slices.lexicon.getRecords();
+      await sliceClient.network.slices.lexicon.getRecords();
 
     if (remainingLexicons.records.length === 0) {
       return renderHTML(<EmptyLexiconState withPadding />, {
···
 
   const sliceUri = buildAtUri({
     did: context.currentUser.sub!,
-    collection: "social.slices.slice",
+    collection: "network.slices.slice",
     rkey: sliceId,
   });
 
   let slice;
   try {
-    slice = await atprotoClient.social.slices.slice.getRecord({
+    slice = await atprotoClient.network.slices.slice.getRecord({
       uri: sliceUri,
     });
   } catch (error) {
···
     pattern: new URLPattern({ pathname: "/api/slices/:id/lexicons/:rkey" }),
     handler: handleDeleteLexicon,
   },
-];
+];

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

···
                 class="font-mono text-sm"
                 placeholder={`{
   "lexicon": 1,
-  "id": "social.slices.example",
+  "id": "network.slices.example",
   "description": "Example record type",
   "defs": {
     "main": {

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

···
 
     // Register new OAuth client via backend API
     const sliceClient = getSliceClient(context, sliceId);
-    const newClient = await sliceClient.social.slices.slice.createOAuthClient({
+    const newClient = await sliceClient.network.slices.slice.createOAuthClient({
       clientName,
       redirectUris,
       scope: scope || undefined,
···
   try {
     // Delete OAuth client via backend API
     const sliceClient = getSliceClient(context, sliceId);
-    await sliceClient.social.slices.slice.deleteOAuthClient(clientId);
+    await sliceClient.network.slices.slice.deleteOAuthClient(clientId);
 
     return renderHTML(<OAuthDeleteResult success />);
   } catch (error) {
···
     // Fetch OAuth client details via backend API
     const sliceClient = getSliceClient(context, sliceId);
     const clientsResponse =
-      await sliceClient.social.slices.slice.getOAuthClients();
+      await sliceClient.network.slices.slice.getOAuthClients();
     const clientData = clientsResponse.clients.find(
       (c) => c.clientId === clientId
     );
 
     const sliceUri = buildAtUri({
       did: context.currentUser.sub!,
-      collection: "social.slices.slice",
+      collection: "network.slices.slice",
       rkey: sliceId,
     });
 
···
     // Update OAuth client via backend API
     const sliceClient = getSliceClient(context, sliceId);
     const updatedClient =
-      await sliceClient.social.slices.slice.updateOAuthClient({
+      await sliceClient.network.slices.slice.updateOAuthClient({
         clientId,
         clientName: clientName || undefined,
         redirectUris: redirectUris.length > 0 ? redirectUris : undefined,
···
 
   const sliceUri = buildAtUri({
     did: context.currentUser.sub!,
-    collection: "social.slices.slice",
+    collection: "network.slices.slice",
     rkey: sliceId,
   });
 
···
 
   let slice;
   try {
-    slice = await atprotoClient.social.slices.slice.getRecord({
+    slice = await atprotoClient.network.slices.slice.getRecord({
       uri: sliceUri,
     });
   } catch (error) {
···
 
   try {
     const oauthClientsResponse =
-      await sliceClient.social.slices.slice.getOAuthClients();
+      await sliceClient.network.slices.slice.getOAuthClients();
     console.log("Fetched OAuth clients:", oauthClientsResponse.clients);
     clientsWithDetails = oauthClientsResponse.clients.map((client) => ({
       clientId: client.clientId,
···
     pattern: new URLPattern({ pathname: "/api/slices/:id/oauth/:uri" }),
     handler: handleOAuthClientDelete,
   },
-];
+];

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

···
   if (context.currentUser.isAuthenticated) {
     try {
       const sliceUri = buildAtUri({
-        did: context.currentUser.sub || "unknown",
-        collection: "social.slices.slice",
+        did: context.currentUser.sub!,
+        collection: "network.slices.slice",
         rkey: sliceId,
       });
 
+      console.log(sliceUri);
+
       const [sliceRecord, stats] = await Promise.all([
-        atprotoClient.social.slices.slice.getRecord({ uri: sliceUri }),
-        atprotoClient.social.slices.slice.stats({ slice: sliceUri }),
+        atprotoClient.network.slices.slice.getRecord({ uri: sliceUri }),
+        atprotoClient.network.slices.slice.stats({ slice: sliceUri }),
       ]);
 
       const collections = stats.success
···
     pattern: new URLPattern({ pathname: "/slices/:id" }),
     handler: handleSliceOverview,
   },
-];
+];

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

···
     try {
       const sliceUri = buildAtUri({
         did: context.currentUser.sub ?? "unknown",
-        collection: "social.slices.slice",
+        collection: "network.slices.slice",
         rkey: sliceId,
       });
 
       const [sliceRecord, stats] = await Promise.all([
-        atprotoClient.social.slices.slice.getRecord({ uri: sliceUri }),
-        atprotoClient.social.slices.slice.stats({ slice: sliceUri }),
+        atprotoClient.network.slices.slice.getRecord({ uri: sliceUri }),
+        atprotoClient.network.slices.slice.stats({ slice: sliceUri }),
       ]);
 
       const collections = stats.success
···
   // Fetch real records if a collection is selected
   let records: Array<IndexedRecord & { pretty_value: string }> = [];
 
-  if (
-    (selectedCollection || searchQuery) &&
-    sliceData.collections.length > 0
-  ) {
+  if ((selectedCollection || searchQuery) && sliceData.collections.length > 0) {
     try {
       const sliceClient = getSliceClient(context, sliceId);
       const recordsResult =
-        await sliceClient.social.slices.slice.getSliceRecords({
+        await sliceClient.network.slices.slice.getSliceRecords({
           where: {
             ...(selectedCollection && {
               collection: { eq: selectedCollection },
···
     pattern: new URLPattern({ pathname: "/slices/:id/records" }),
     handler: handleSliceRecordsPage,
   },
-];
+];

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

···
 
   try {
     const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
-    const slice = await atprotoClient.social.slices.slice.getRecord({
+    const slice = await atprotoClient.network.slices.slice.getRecord({
       uri: sliceUri,
     });
 
···
     const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
 
     // Get the current record first
-    const currentRecord = await atprotoClient.social.slices.slice.getRecord({
+    const currentRecord = await atprotoClient.network.slices.slice.getRecord({
       uri: sliceUri,
     });
 
     // Update the record with new name and domain
-    await atprotoClient.social.slices.slice.updateRecord(sliceId, {
+    await atprotoClient.network.slices.slice.updateRecord(sliceId, {
       ...currentRecord.value,
       name: name.trim(),
       domain: domain.trim(),
···
 
   try {
     // Delete the slice record from AT Protocol
-    await atprotoClient.social.slices.slice.deleteRecord(sliceId);
+    await atprotoClient.network.slices.slice.deleteRecord(sliceId);
 
     return hxRedirect("/");
   } catch (_error) {

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

···
   let slice: { name: string } = { name: "Unknown Slice" };
   try {
     const sliceClient = getSliceClient(context, sliceId);
-    const sliceRecord = await sliceClient.social.slices.slice.getRecord({
+    const sliceRecord = await sliceClient.network.slices.slice.getRecord({
       uri: buildAtUri({
         did: context.currentUser.sub!,
-        collection: "social.slices.slice",
+        collection: "network.slices.slice",
         rkey: sliceId,
       }),
     });
···
 
   try {
     const sliceClient = getSliceClient(context, sliceId);
-    const logsResponse = await sliceClient.social.slices.slice.getJobLogs({
+    const logsResponse = await sliceClient.network.slices.slice.getJobLogs({
       jobId,
     });
 
···
     pattern: new URLPattern({ pathname: "/api/slices/:id/sync/logs/:jobId" }),
     handler: handleSyncJobLogs,
   },
-];
+];

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

···
   const sliceId = params?.pathname.groups.id;
 
   if (!sliceId) {
-    return renderHTML(
-      <SyncResult success={false} error="Invalid slice ID" />
-    );
+    return renderHTML(<SyncResult success={false} error="Invalid slice ID" />);
   }
 
   try {
···
     }
 
     const sliceClient = getSliceClient(context, sliceId);
-    const syncJobResponse = await sliceClient.social.slices.slice.startSync({
+    const syncJobResponse = await sliceClient.network.slices.slice.startSync({
       collections: collections.length > 0 ? collections : undefined,
       externalCollections:
         externalCollections.length > 0 ? externalCollections : undefined,
···
   try {
     const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
     const sliceClient = getSliceClient(context, sliceId);
-    const jobsResponse = await sliceClient.social.slices.slice.getJobHistory({
+    const jobsResponse = await sliceClient.network.slices.slice.getJobHistory({
       userDid: context.currentUser.sub!,
       sliceUri: sliceUri,
       limit: 10,
···
   // Get the slice record
   const sliceUri = buildAtUri({
     did: context.currentUser.sub!,
-    collection: "social.slices.slice",
+    collection: "network.slices.slice",
     rkey: sliceId,
   });
 
···
   const externalCollections: string[] = [];
 
   try {
-    slice = await atprotoClient.social.slices.slice.getRecord({
+    slice = await atprotoClient.network.slices.slice.getRecord({
       uri: sliceUri,
     });
 
     // Get all lexicons and filter by record types
     try {
       const lexiconsResponse =
-        await sliceClient.social.slices.lexicon.getRecords();
+        await sliceClient.network.slices.lexicon.getRecords();
       const recordLexicons = lexiconsResponse.records.filter((lexicon) => {
         try {
           const definitions = JSON.parse(lexicon.value.definitions);
···
     pattern: new URLPattern({ pathname: "/api/slices/:id/job-history" }),
     handler: handleJobHistory,
   },
-];
+];

frontend/src/utils/at-uri.ts

···
  * Format: at://did:method:identifier/collection/rkey#fragment
  */
 export function parseAtUri(uri: string): AtUri {
-  if (!uri.startsWith('at://')) {
+  if (!uri.startsWith("at://")) {
     throw new Error(`Invalid AT-URI: must start with at:// - got ${uri}`);
   }
 
   const withoutProtocol = uri.slice(5); // Remove 'at://'
-  const [didAndPath, fragment] = withoutProtocol.split('#');
-  const parts = didAndPath.split('/');
+  const [didAndPath, fragment] = withoutProtocol.split("#");
+  const parts = didAndPath.split("/");
 
   if (parts.length < 3) {
     throw new Error(`Invalid AT-URI: missing required parts - got ${uri}`);
···
   }
 
   return {
-    protocol: 'at',
+    protocol: "at",
     did,
     collection,
     rkey,
-    fragment
+    fragment,
   };
 }
 
 /**
  * Build an AT-URI from components
  */
-export function buildAtUri(components: Omit<AtUri, 'protocol'>): string {
+export function buildAtUri(components: Omit<AtUri, "protocol">): string {
   const { did, collection, rkey, fragment } = components;
   let uri = `at://${did}/${collection}/${rkey}`;
-  
+
   if (fragment) {
     uri += `#${fragment}`;
   }
-  
+
   return uri;
 }
 
···
  * Build a slice URI from DID and slice ID
  */
 export function buildSliceUri(did: string, sliceId: string): string {
-  return buildAtUri({ did, collection: "social.slices.slice", rkey: sliceId });
-}
+  return buildAtUri({ did, collection: "network.slices.slice", rkey: sliceId });
+}

frontend/src/utils/client.ts

···
 }
 
 // Helper function to get a slice-specific AT Protocol client
-export function getSliceClient(context: AuthContext, sliceId: string): AtProtoClient {
+export function getSliceClient(
+  context: AuthContext,
+  sliceId: string
+): AtProtoClient {
   const API_URL = Deno.env.get("API_URL")!;
-  
+
   if (!context.currentUser.sub) {
     throw new Error("User DID is required to create slice client");
   }
-  
+
   const sliceUri = buildAtUri({
     did: context.currentUser.sub,
-    collection: "social.slices.slice",
+    collection: "network.slices.slice",
     rkey: sliceId,
   });
   return new AtProtoClient(API_URL, sliceUri, atprotoClient.oauth);
-}
+}

lexicons/social/slices/lexicon.json lexicons/network/slices/lexicon.json

···
 {
   "lexicon": 1,
-  "id": "social.slices.lexicon",
+  "id": "network.slices.lexicon",
   "description": "Lexicon definition record type for AT Protocol schema storage",
   "defs": {
     "main": {

lexicons/social/slices/profile.json lexicons/network/slices/profile.json

···
 {
   "lexicon": 1,
-  "id": "social.slices.actor.profile",
+  "id": "network.slices.actor.profile",
   "defs": {
     "main": {
       "type": "record",

lexicons/social/slices/slice.json lexicons/network/slices/slice.json

···
 {
   "lexicon": 1,
-  "id": "social.slices.slice",
+  "id": "network.slices.slice",
   "description": "Slice application record type",
   "defs": {
     "main": {