update to latest slices apis

deno.json

···
 {
   "imports": {
+    "@slices/client": "jsr:@slices/client@~0.1.0-alpha.2",
+    "@slices/oauth": "jsr:@slices/oauth@^0.4.1",
     "github-colors": "npm:github-colors@^2.2.21",
     "preact": "npm:preact@^10.27.1",
     "preact-render-to-string": "npm:preact-render-to-string@^6.6.1",

deno.lock

···
 {
   "version": "5",
   "specifiers": {
+    "jsr:@slices/client@~0.1.0-alpha.2": "0.1.0-alpha.2",
     "jsr:@slices/oauth@~0.3.2": "0.3.2",
+    "jsr:@slices/oauth@~0.4.1": "0.4.1",
     "npm:@resvg/resvg-js@^2.6.2": "2.6.2",
     "npm:@resvg/resvg-wasm@^2.6.2": "2.6.2",
     "npm:@takumi-rs/core@~0.29.8": "0.29.8",
···
     "npm:satori@~0.18.2": "0.18.2"
   },
   "jsr": {
+    "@slices/client@0.1.0-alpha.2": {
+      "integrity": "d3c591e89ab5b7ed7988faf9428bb7b3539484c6b90005a7c66f2188cc60fe19"
+    },
     "@slices/oauth@0.3.2": {
       "integrity": "51feaa6be538a61a3278ee7f1d264ed937187d09da2be1f0a2a837128df82526"
+    },
+    "@slices/oauth@0.4.1": {
+      "integrity": "15f20df2ba81e9d1764291c8b4f6e3eb38cfc953750eeb3815872b7e22475492"
     }
   },
   "npm": {
···
   },
   "workspace": {
     "dependencies": [
+      "jsr:@slices/client@~0.1.0-alpha.2",
+      "jsr:@slices/oauth@~0.4.1",
       "npm:@takumi-rs/core@~0.29.8",
       "npm:@takumi-rs/helpers@~0.29.8",
       "npm:github-colors@^2.2.21",

src/components/RecentSearches.tsx

···
 import {
   type ShTangledRepo,
   type AppBskyActorProfile,
-  type Actor,
-  type IndexedRecord,
 } from "../generated_client.ts";
+import { type Actor, type IndexedRecord } from "@slices/client";
 
 const RecentSearches = ({
   recentRecords,

src/components/SearchPage.tsx

···
 import Layout from "./Layout.tsx";
 import RecentSearches from "./RecentSearches.tsx";
-import { type Actor, type IndexedRecord } from "../generated_client.ts";
+import { type Actor, type IndexedRecord } from "@slices/client";
 
 const SearchPage = ({
   recentRecords,

src/components/SearchResults.tsx

···
 import {
   type ShTangledRepo,
   type AppBskyActorProfile,
-  type Actor,
-  type IndexedRecord,
-  recordBlobToCdnUrl,
 } from "../generated_client.ts";
+import { IndexedRecord, Actor, recordBlobToCdnUrl } from "@slices/client";
 
 const SearchResults = ({
   results,

src/generated_client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-09-03 18:04:36 UTC
-// Lexicons: 5
+// Generated at: 2025-09-14 18:49:29 UTC
+// Lexicons: 7
 
 /**
  * @example Usage
···
  *
  * const client = new AtProtoClient(
  *   'https://slices-api.fly.dev',
- *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lx6lhk7ibk2q'
+ *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhhbxald2z'
  * );
  *
- * // Get records from the sh.tangled.repo collection
- * const records = await client.sh.tangled.repo.getRecords();
+ * // Get records from the sh.tangled.feed.star collection
+ * const records = await client.sh.tangled.feed.star.getRecords();
  *
  * // Get a specific record
- * const record = await client.sh.tangled.repo.getRecord({
- *   uri: 'at://did:plc:example/sh.tangled.repo/3abc123'
+ * const record = await client.sh.tangled.feed.star.getRecord({
+ *   uri: 'at://did:plc:example/sh.tangled.feed.star/3abc123'
  * });
  *
  * // Get records with filtering and search
- * const filteredRecords = await client.sh.tangled.repo.getRecords({
+ * const filteredRecords = await client.sh.tangled.feed.star.getRecords({
  *   where: {
  *     text: { contains: "example search term" }
  *   }
  * });
  *
  * // Use slice-level methods for cross-collection queries with type safety
- * const sliceRecords = await client.social.slices.slice.getSliceRecords<ShTangledRepo>({
+ * const sliceRecords = await client.network.slices.slice.getSliceRecords<ShTangledFeedStar>({
  *   where: {
- *     collection: { eq: 'sh.tangled.repo' }
+ *     collection: { eq: 'sh.tangled.feed.star' }
  *   }
  * });
  *
  * // Search across multiple collections using union types
- * const multiCollectionRecords = await client.social.slices.slice.getSliceRecords<ShTangledRepo | AppBskyActorProfile>({
+ * const multiCollectionRecords = await client.network.slices.slice.getSliceRecords<ShTangledFeedStar | AppBskyActorProfile>({
  *   where: {
- *     collection: { in: ['sh.tangled.repo', 'app.bsky.actor.profile'] },
+ *     collection: { in: ['sh.tangled.feed.star', 'app.bsky.actor.profile'] },
  *     text: { contains: 'example search term' },
  *     did: { in: ['did:plc:user1', 'did:plc:user2'] }
  *   },
···
  * ```
  */
 
-import { OAuthClient } from "jsr:@slices/oauth@^0.3.2";
-
-export interface RecordResponse<T> {
-  uri: string;
-  cid: string;
-  did: string;
-  collection: string;
-  value: T;
-  indexedAt: string;
-}
-
-export interface GetActorsResponse {
-  actors: Actor[];
-  cursor?: string;
-}
-
-export interface GetRecordsResponse<T> {
-  records: RecordResponse<T>[];
-  cursor?: string;
-}
-
-export interface CountRecordsResponse {
-  success: boolean;
-  count: number;
-  message?: string;
-}
-
-export interface GetRecordParams {
-  uri: string;
-}
-
-export type ActorWhereConditions = Partial<
-  Record<"did" | "handle" | "indexed_at", WhereCondition>
->;
-
-export interface GetActorsParams {
-  limit?: number;
-  cursor?: string;
-  where?: ActorWhereConditions;
-}
-
-export interface IndexedRecord<T = Record<string, unknown>> {
-  uri: string;
-  cid: string;
-  did: string;
-  collection: string;
-  value: T;
-  indexedAt: string;
-}
-
-export interface Actor {
-  did: string;
-  handle?: string;
-  sliceUri: string;
-  indexedAt: string;
-}
-
-export interface CodegenXrpcRequest {
-  target: string;
-  slice: string;
-}
-
-export interface CodegenXrpcResponse {
-  success: boolean;
-  generatedCode?: string;
-  error?: string;
-}
-
-export interface BulkSyncParams {
-  collections?: string[];
-  externalCollections?: string[];
-  repos?: string[];
-  limitPerRepo?: number;
-}
-
-export interface BulkSyncOutput {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-export interface SyncJobResponse {
-  success: boolean;
-  jobId?: string;
-  message: string;
-}
-
-export interface SyncJobResult {
-  success: boolean;
-  totalRecords: number;
-  collectionsSynced: string[];
-  reposProcessed: number;
-  message: string;
-}
-
-export interface JobStatus {
-  jobId: string;
-  status: string;
-  createdAt: string;
-  startedAt?: string;
-  completedAt?: string;
-  result?: SyncJobResult;
-  error?: string;
-  retryCount: number;
-}
-
-export interface GetJobStatusParams {
-  jobId: string;
-}
-
-export interface GetJobHistoryParams {
-  userDid: string;
-  sliceUri: string;
-  limit?: number;
-}
-
-export type GetJobHistoryResponse = JobStatus[];
-
-export interface SyncUserCollectionsRequest {
-  slice: string;
-  timeoutSeconds?: number;
-}
-
-export interface SyncUserCollectionsResult {
-  success: boolean;
-  reposProcessed: number;
-  recordsSynced: number;
-  timedOut: boolean;
-  message: string;
-}
-
-export interface JetstreamStatusResponse {
-  connected: boolean;
-  status: string;
-  error?: string;
-}
-
-export interface CollectionStats {
-  collection: string;
-  recordCount: number;
-  uniqueActors: number;
-}
-
-export interface SliceStatsParams {
-  slice: string;
-}
-
-export interface SliceStatsOutput {
-  success: boolean;
-  collections: string[];
-  collectionStats: CollectionStats[];
-  totalLexicons: number;
-  totalRecords: number;
-  totalActors: number;
-  message?: string;
-}
-
-export interface WhereCondition {
-  eq?: string;
-  in?: string[];
-  contains?: string;
-}
-
-export type WhereClause<T extends string = string> = {
-  [K in T]?: WhereCondition;
-};
-export type IndexedRecordFields =
-  | "did"
-  | "collection"
-  | "uri"
-  | "cid"
-  | "indexedAt";
-
-export interface SortField<TField extends string = string> {
-  field: TField;
-  direction: "asc" | "desc";
-}
-
-export interface SliceRecordsParams<TSortField extends string = string> {
-  slice: string;
-  limit?: number;
-  cursor?: string;
-  where?: { [K in TSortField | IndexedRecordFields]?: WhereCondition };
-  orWhere?: { [K in TSortField | IndexedRecordFields]?: WhereCondition };
-  sortBy?: SortField<TSortField>[];
-}
-
-export interface SliceLevelRecordsParams<TRecord = Record<string, unknown>> {
-  slice: string;
-  limit?: number;
-  cursor?: string;
-  where?: { [K in keyof TRecord | IndexedRecordFields]?: WhereCondition };
-  orWhere?: { [K in keyof TRecord | IndexedRecordFields]?: WhereCondition };
-  sortBy?: SortField[];
-}
-
-export interface SliceRecordsOutput<T = Record<string, unknown>> {
-  success: boolean;
-  records: IndexedRecord<T>[];
-  cursor?: string;
-  message?: string;
-}
-
-export interface UploadBlobRequest {
-  data: ArrayBuffer | Uint8Array;
-  mimeType: string;
-}
-
-export interface BlobRef {
-  $type: string;
-  ref: { $link: string };
-  mimeType: string;
-  size: number;
-}
-
-export interface UploadBlobResponse {
-  blob: BlobRef;
-}
-
-export interface CollectionOperations<T, TSortField extends string = string> {
-  getRecords(
-    params?: Omit<SliceRecordsParams<TSortField>, "slice">
-  ): Promise<GetRecordsResponse<T>>;
-  getRecord(params: GetRecordParams): Promise<RecordResponse<T>>;
-}
-
-export interface ShTangledRepo {
-  createdAt: string;
-  description?: string;
-  /** knot where the repo was created */
-  knot: string;
-  /** name of the repo */
-  name: string;
-  owner: string;
-  /** source of the repo */
-  source?: string;
-  /** CI runner to send jobs to and receive results from */
-  spindle?: string;
-}
-
-export type ShTangledRepoSortFields =
-  | "createdAt"
-  | "description"
-  | "knot"
-  | "name"
-  | "owner"
-  | "source"
-  | "spindle";
-
-export interface AppBskyActorProfile {
-  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
-  avatar?: BlobRef;
-  /** Larger horizontal image to display behind profile view. */
-  banner?: BlobRef;
-  createdAt?: string;
-  /** Free-form profile description text. */
-  description?: string;
-  displayName?: string;
-  joinedViaStarterPack?: ComAtprotoRepoStrongRef;
-  /** Self-label values, specific to the Bluesky application, on the overall account. */
-  labels?:
-    | ComAtprotoLabelDefs["SelfLabels"]
-    | {
-        $type: string;
-        [key: string]: unknown;
-      };
-  pinnedPost?: ComAtprotoRepoStrongRef;
-}
-
-export type AppBskyActorProfileSortFields =
-  | "createdAt"
-  | "description"
-  | "displayName";
+import {
+  type BlobRef,
+  type CountRecordsResponse,
+  type GetRecordParams,
+  type GetRecordsResponse,
+  type IndexedRecordFields,
+  type RecordResponse,
+  SlicesClient,
+  type SortField,
+  type WhereCondition,
+} from "jsr:@slices/client@^0.1.0-alpha.2";
+import { OAuthClient } from "jsr:@slices/oauth@^0.4.1";
 
 export interface ShTangledFeedStar {
   createdAt: string;
···
 }
 
 export type ShTangledFeedStarSortFields = "createdAt" | "subject";
+
+export interface ComAtprotoRepoStrongRef {
+  cid: string;
+  uri: string;
+}
 
 export interface ComAtprotoLabelDefsLabel {
   /** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
···
   values: ComAtprotoLabelDefs["SelfLabel"][];
 }
 
-export interface ComAtprotoRepoStrongRef {
-  cid: string;
-  uri: string;
+export interface AppBskyActorProfile {
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef;
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef;
+  createdAt?: string;
+  /** Free-form profile description text. */
+  description?: string;
+  displayName?: string;
+  joinedViaStarterPack?: ComAtprotoRepoStrongRef;
+  /** Self-label values, specific to the Bluesky application, on the overall account. */
+  labels?:
+    | ComAtprotoLabelDefs["SelfLabels"]
+    | {
+        $type: string;
+        [key: string]: unknown;
+      };
+  pinnedPost?: ComAtprotoRepoStrongRef;
 }
 
+export type AppBskyActorProfileSortFields =
+  | "createdAt"
+  | "description"
+  | "displayName";
+
+export interface ShTangledActorProfile {
+  /** Include link to this account on Bluesky. */
+  bluesky: boolean;
+  /** Free-form profile description text. */
+  description?: string;
+  links?: string[];
+  /** Free-form location text. */
+  location?: string;
+  /** Any ATURI, it is up to appviews to validate these fields. */
+  pinnedRepositories?: string[];
+  stats?: string[];
+}
+
+export type ShTangledActorProfileSortFields = "description" | "location";
+
+export interface ShTangledRepo {
+  createdAt: string;
+  description?: string;
+  /** knot where the repo was created */
+  knot: string;
+  /** name of the repo */
+  name: string;
+  owner: string;
+  /** source of the repo */
+  source?: string;
+  /** CI runner to send jobs to and receive results from */
+  spindle?: string;
+}
+
+export type ShTangledRepoSortFields =
+  | "createdAt"
+  | "description"
+  | "knot"
+  | "name"
+  | "owner"
+  | "source"
+  | "spindle";
+
+export interface ShTangledRepoIssue {
+  body?: string;
+  createdAt: string;
+  repo: string;
+  title: string;
+}
+
+export type ShTangledRepoIssueSortFields =
+  | "body"
+  | "createdAt"
+  | "repo"
+  | "title";
+
 export interface ComAtprotoLabelDefs {
   readonly Label: ComAtprotoLabelDefsLabel;
   readonly LabelValueDefinition: ComAtprotoLabelDefsLabelValueDefinition;
···
   readonly SelfLabels: ComAtprotoLabelDefsSelfLabels;
 }
 
-class BaseClient {
-  protected readonly baseUrl: string;
-  protected oauthClient?: OAuthClient;
+class StarFeedTangledShClient {
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, oauthClient?: OAuthClient) {
-    this.baseUrl = baseUrl;
-    this.oauthClient = oauthClient;
+  constructor(client: SlicesClient) {
+    this.client = client;
   }
 
-  protected async ensureValidToken(): Promise<void> {
-    if (!this.oauthClient) {
-      throw new Error("OAuth client not configured");
-    }
-
-    await this.oauthClient.ensureValidToken();
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<ShTangledFeedStarSortFields>[];
+  }): Promise<GetRecordsResponse<ShTangledFeedStar>> {
+    return await this.client.getRecords("sh.tangled.feed.star", params);
   }
 
-  protected async makeRequest<T = unknown>(
-    endpoint: string,
-    method?: "GET" | "POST" | "PUT" | "DELETE",
-    params?: Record<string, unknown> | unknown
-  ): Promise<T> {
-    return this.makeRequestWithRetry(endpoint, method, params, false);
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<ShTangledFeedStar>> {
+    return await this.client.getRecord("sh.tangled.feed.star", params);
   }
 
-  private async makeRequestWithRetry<T = unknown>(
-    endpoint: string,
-    method?: "GET" | "POST" | "PUT" | "DELETE",
-    params?: Record<string, unknown> | unknown,
-    isRetry?: boolean
-  ): Promise<T> {
-    isRetry = isRetry ?? false;
-    const httpMethod = method || "GET";
-    let url = `${this.baseUrl}/xrpc/${endpoint}`;
-
-    const requestInit: RequestInit = {
-      method: httpMethod,
-      headers: {},
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
     };
+    orWhere?: {
+      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<ShTangledFeedStarSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords("sh.tangled.feed.star", params);
+  }
 
-    // Add authorization header if OAuth client is available
-    if (this.oauthClient) {
-      try {
-        const tokens = await this.oauthClient.ensureValidToken();
-        if (tokens.accessToken) {
-          (requestInit.headers as Record<string, string>)[
-            "Authorization"
-          ] = `${tokens.tokenType} ${tokens.accessToken}`;
-        }
-      } catch (tokenError) {
-        // For write operations, OAuth tokens are required (excluding read endpoints that use POST)
-        const isReadEndpoint =
-          endpoint.includes(".getRecords") ||
-          endpoint.includes(".getSliceRecords") ||
-          endpoint.includes(".stats");
-        if (httpMethod !== "GET" && !isReadEndpoint) {
-          throw new Error(
-            `Authentication required: OAuth tokens are invalid or expired. Please log in again.`
-          );
-        }
+  async createRecord(
+    record: ShTangledFeedStar,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "sh.tangled.feed.star",
+      record,
+      useSelfRkey
+    );
+  }
 
-        // For read operations, continue without auth (allow read-only operations)
-      }
-    }
+  async updateRecord(
+    rkey: string,
+    record: ShTangledFeedStar
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord("sh.tangled.feed.star", rkey, record);
+  }
 
-    if (httpMethod === "GET" && params) {
-      const searchParams = new URLSearchParams();
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          searchParams.append(key, String(value));
-        }
-      });
-      const queryString = searchParams.toString();
-      if (queryString) {
-        url += "?" + queryString;
-      }
-    } else if (httpMethod !== "GET" && params) {
-      // Regular API endpoints expect JSON
-      (requestInit.headers as Record<string, string>)["Content-Type"] =
-        "application/json";
-      requestInit.body = JSON.stringify(params);
-    }
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord("sh.tangled.feed.star", rkey);
+  }
+}
 
-    const response = await fetch(url, requestInit);
-    if (!response.ok) {
-      // Handle 404 gracefully for GET requests
-      if (response.status === 404 && httpMethod === "GET") {
-        return null as T;
-      }
+class FeedTangledShClient {
+  readonly star: StarFeedTangledShClient;
+  private readonly client: SlicesClient;
 
-      // Handle 401 Unauthorized - attempt token refresh and retry once
-      const isReadEndpoint =
-        endpoint.includes(".getRecords") ||
-        endpoint.includes(".getSliceRecords") ||
-        endpoint.includes(".stats");
-      if (
-        response.status === 401 &&
-        !isRetry &&
-        this.oauthClient &&
-        httpMethod !== "GET" &&
-        !isReadEndpoint
-      ) {
-        try {
-          // Force token refresh by calling ensureValidToken again
-          await this.oauthClient.ensureValidToken();
-          // Retry the request once with refreshed tokens
-          return this.makeRequestWithRetry(endpoint, method, params, true);
-        } catch (_refreshError) {
-          throw new Error(
-            `Authentication required: OAuth tokens are invalid or expired. Please log in again.`
-          );
-        }
-      }
-
-      throw new Error(
-        `Request failed: ${response.status} ${response.statusText}`
-      );
-    }
-
-    return (await response.json()) as T;
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.star = new StarFeedTangledShClient(client);
   }
 }
 
-class RepoTangledShClient extends BaseClient {
-  private readonly sliceUri: string;
+class ProfileActorTangledShClient {
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
+  constructor(client: SlicesClient) {
+    this.client = client;
   }
 
   async getRecords(params?: {
     limit?: number;
     cursor?: string;
     where?: {
-      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledActorProfileSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
-      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledActorProfileSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<ShTangledRepoSortFields>[];
-  }): Promise<GetRecordsResponse<ShTangledRepo>> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    const result = await this.makeRequest<SliceRecordsOutput>(
-      "sh.tangled.repo.getRecords",
-      "POST",
-      requestParams
-    );
-    return {
-      records: result.records.map((record) => ({
-        uri: record.uri,
-        cid: record.cid,
-        did: record.did,
-        collection: record.collection,
-        value: record.value as unknown as ShTangledRepo,
-        indexedAt: record.indexedAt,
-      })),
-      cursor: result.cursor,
-    };
+    sortBy?: SortField<ShTangledActorProfileSortFields>[];
+  }): Promise<GetRecordsResponse<ShTangledActorProfile>> {
+    return await this.client.getRecords("sh.tangled.actor.profile", params);
   }
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<ShTangledRepo>> {
-    const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<ShTangledRepo>>(
-      "sh.tangled.repo.getRecord",
-      "GET",
-      requestParams
-    );
+  ): Promise<RecordResponse<ShTangledActorProfile>> {
+    return await this.client.getRecord("sh.tangled.actor.profile", params);
   }
 
   async countRecords(params?: {
     limit?: number;
     cursor?: string;
     where?: {
-      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledActorProfileSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
-      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledActorProfileSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<ShTangledRepoSortFields>[];
+    sortBy?: SortField<ShTangledActorProfileSortFields>[];
   }): Promise<CountRecordsResponse> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    return await this.makeRequest<CountRecordsResponse>(
-      "sh.tangled.repo.countRecords",
-      "POST",
-      requestParams
-    );
+    return await this.client.countRecords("sh.tangled.actor.profile", params);
   }
 
   async createRecord(
-    record: ShTangledRepo,
+    record: ShTangledActorProfile,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "sh.tangled.repo", ...record };
-    const payload = {
-      slice: this.sliceUri,
-      ...(useSelfRkey ? { rkey: "self" } : {}),
-      record: recordValue,
-    };
-    return await this.makeRequest<{ uri: string; cid: string }>(
-      "sh.tangled.repo.createRecord",
-      "POST",
-      payload
+    return await this.client.createRecord(
+      "sh.tangled.actor.profile",
+      record,
+      useSelfRkey
     );
   }
 
   async updateRecord(
     rkey: string,
-    record: ShTangledRepo
+    record: ShTangledActorProfile
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "sh.tangled.repo", ...record };
-    const payload = {
-      slice: this.sliceUri,
+    return await this.client.updateRecord(
+      "sh.tangled.actor.profile",
       rkey,
-      record: recordValue,
-    };
-    return await this.makeRequest<{ uri: string; cid: string }>(
-      "sh.tangled.repo.updateRecord",
-      "POST",
-      payload
+      record
     );
   }
 
   async deleteRecord(rkey: string): Promise<void> {
-    return await this.makeRequest<void>(
-      "sh.tangled.repo.deleteRecord",
-      "POST",
-      { rkey }
-    );
+    return await this.client.deleteRecord("sh.tangled.actor.profile", rkey);
   }
 }
 
-class StarFeedTangledShClient extends BaseClient {
-  private readonly sliceUri: string;
+class ActorTangledShClient {
+  readonly profile: ProfileActorTangledShClient;
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.profile = new ProfileActorTangledShClient(client);
+  }
+}
+
+class IssueRepoTangledShClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
   }
 
   async getRecords(params?: {
     limit?: number;
     cursor?: string;
     where?: {
-      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledRepoIssueSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
-      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledRepoIssueSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<ShTangledFeedStarSortFields>[];
-  }): Promise<GetRecordsResponse<ShTangledFeedStar>> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    const result = await this.makeRequest<SliceRecordsOutput>(
-      "sh.tangled.feed.star.getRecords",
-      "POST",
-      requestParams
-    );
-    return {
-      records: result.records.map((record) => ({
-        uri: record.uri,
-        cid: record.cid,
-        did: record.did,
-        collection: record.collection,
-        value: record.value as unknown as ShTangledFeedStar,
-        indexedAt: record.indexedAt,
-      })),
-      cursor: result.cursor,
-    };
+    sortBy?: SortField<ShTangledRepoIssueSortFields>[];
+  }): Promise<GetRecordsResponse<ShTangledRepoIssue>> {
+    return await this.client.getRecords("sh.tangled.repo.issue", params);
   }
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<ShTangledFeedStar>> {
-    const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<ShTangledFeedStar>>(
-      "sh.tangled.feed.star.getRecord",
-      "GET",
-      requestParams
-    );
+  ): Promise<RecordResponse<ShTangledRepoIssue>> {
+    return await this.client.getRecord("sh.tangled.repo.issue", params);
   }
 
   async countRecords(params?: {
     limit?: number;
     cursor?: string;
     where?: {
-      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledRepoIssueSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
     orWhere?: {
-      [K in ShTangledFeedStarSortFields | IndexedRecordFields]?: WhereCondition;
+      [K in
+        | ShTangledRepoIssueSortFields
+        | IndexedRecordFields]?: WhereCondition;
     };
-    sortBy?: SortField<ShTangledFeedStarSortFields>[];
+    sortBy?: SortField<ShTangledRepoIssueSortFields>[];
   }): Promise<CountRecordsResponse> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    return await this.makeRequest<CountRecordsResponse>(
-      "sh.tangled.feed.star.countRecords",
-      "POST",
-      requestParams
-    );
+    return await this.client.countRecords("sh.tangled.repo.issue", params);
   }
 
   async createRecord(
-    record: ShTangledFeedStar,
+    record: ShTangledRepoIssue,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "sh.tangled.feed.star", ...record };
-    const payload = {
-      slice: this.sliceUri,
-      ...(useSelfRkey ? { rkey: "self" } : {}),
-      record: recordValue,
-    };
-    return await this.makeRequest<{ uri: string; cid: string }>(
-      "sh.tangled.feed.star.createRecord",
-      "POST",
-      payload
+    return await this.client.createRecord(
+      "sh.tangled.repo.issue",
+      record,
+      useSelfRkey
     );
   }
 
   async updateRecord(
     rkey: string,
-    record: ShTangledFeedStar
+    record: ShTangledRepoIssue
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "sh.tangled.feed.star", ...record };
-    const payload = {
-      slice: this.sliceUri,
+    return await this.client.updateRecord(
+      "sh.tangled.repo.issue",
       rkey,
-      record: recordValue,
-    };
-    return await this.makeRequest<{ uri: string; cid: string }>(
-      "sh.tangled.feed.star.updateRecord",
-      "POST",
-      payload
+      record
     );
   }
 
   async deleteRecord(rkey: string): Promise<void> {
-    return await this.makeRequest<void>(
-      "sh.tangled.feed.star.deleteRecord",
-      "POST",
-      { rkey }
-    );
+    return await this.client.deleteRecord("sh.tangled.repo.issue", rkey);
   }
 }
 
-class FeedTangledShClient extends BaseClient {
-  readonly star: StarFeedTangledShClient;
-  private readonly sliceUri: string;
+class RepoTangledShClient {
+  readonly issue: IssueRepoTangledShClient;
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.issue = new IssueRepoTangledShClient(client);
+  }
+
+  async getRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<ShTangledRepoSortFields>[];
+  }): Promise<GetRecordsResponse<ShTangledRepo>> {
+    return await this.client.getRecords("sh.tangled.repo", params);
+  }
+
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<ShTangledRepo>> {
+    return await this.client.getRecord("sh.tangled.repo", params);
+  }
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.star = new StarFeedTangledShClient(baseUrl, sliceUri, oauthClient);
+  async countRecords(params?: {
+    limit?: number;
+    cursor?: string;
+    where?: {
+      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    orWhere?: {
+      [K in ShTangledRepoSortFields | IndexedRecordFields]?: WhereCondition;
+    };
+    sortBy?: SortField<ShTangledRepoSortFields>[];
+  }): Promise<CountRecordsResponse> {
+    return await this.client.countRecords("sh.tangled.repo", params);
+  }
+
+  async createRecord(
+    record: ShTangledRepo,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "sh.tangled.repo",
+      record,
+      useSelfRkey
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: ShTangledRepo
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord("sh.tangled.repo", rkey, record);
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord("sh.tangled.repo", rkey);
   }
 }
 
-class TangledShClient extends BaseClient {
+class TangledShClient {
+  readonly feed: FeedTangledShClient;
+  readonly actor: ActorTangledShClient;
   readonly repo: RepoTangledShClient;
-  readonly feed: FeedTangledShClient;
-  private readonly sliceUri: string;
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.repo = new RepoTangledShClient(baseUrl, sliceUri, oauthClient);
-    this.feed = new FeedTangledShClient(baseUrl, sliceUri, oauthClient);
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.feed = new FeedTangledShClient(client);
+    this.actor = new ActorTangledShClient(client);
+    this.repo = new RepoTangledShClient(client);
   }
 }
 
-class ShClient extends BaseClient {
+class ShClient {
   readonly tangled: TangledShClient;
-  private readonly sliceUri: string;
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.tangled = new TangledShClient(baseUrl, sliceUri, oauthClient);
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.tangled = new TangledShClient(client);
   }
 }
 
-class ProfileActorBskyAppClient extends BaseClient {
-  private readonly sliceUri: string;
+class ProfileActorBskyAppClient {
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
+  constructor(client: SlicesClient) {
+    this.client = client;
   }
 
   async getRecords(params?: {
···
     };
     sortBy?: SortField<AppBskyActorProfileSortFields>[];
   }): Promise<GetRecordsResponse<AppBskyActorProfile>> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    const result = await this.makeRequest<SliceRecordsOutput>(
-      "app.bsky.actor.profile.getRecords",
-      "POST",
-      requestParams
-    );
-    return {
-      records: result.records.map((record) => ({
-        uri: record.uri,
-        cid: record.cid,
-        did: record.did,
-        collection: record.collection,
-        value: record.value as unknown as AppBskyActorProfile,
-        indexedAt: record.indexedAt,
-      })),
-      cursor: result.cursor,
-    };
+    return await this.client.getRecords("app.bsky.actor.profile", params);
   }
 
   async getRecord(
     params: GetRecordParams
   ): Promise<RecordResponse<AppBskyActorProfile>> {
-    const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<AppBskyActorProfile>>(
-      "app.bsky.actor.profile.getRecord",
-      "GET",
-      requestParams
-    );
+    return await this.client.getRecord("app.bsky.actor.profile", params);
   }
 
   async countRecords(params?: {
···
     };
     sortBy?: SortField<AppBskyActorProfileSortFields>[];
   }): Promise<CountRecordsResponse> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    return await this.makeRequest<CountRecordsResponse>(
-      "app.bsky.actor.profile.countRecords",
-      "POST",
-      requestParams
-    );
+    return await this.client.countRecords("app.bsky.actor.profile", params);
   }
 
   async createRecord(
     record: AppBskyActorProfile,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "app.bsky.actor.profile", ...record };
-    const payload = {
-      slice: this.sliceUri,
-      ...(useSelfRkey ? { rkey: "self" } : {}),
-      record: recordValue,
-    };
-    return await this.makeRequest<{ uri: string; cid: string }>(
-      "app.bsky.actor.profile.createRecord",
-      "POST",
-      payload
+    return await this.client.createRecord(
+      "app.bsky.actor.profile",
+      record,
+      useSelfRkey
     );
   }
 
···
     rkey: string,
     record: AppBskyActorProfile
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "app.bsky.actor.profile", ...record };
-    const payload = {
-      slice: this.sliceUri,
+    return await this.client.updateRecord(
+      "app.bsky.actor.profile",
       rkey,
-      record: recordValue,
-    };
-    return await this.makeRequest<{ uri: string; cid: string }>(
-      "app.bsky.actor.profile.updateRecord",
-      "POST",
-      payload
+      record
     );
   }
 
   async deleteRecord(rkey: string): Promise<void> {
-    return await this.makeRequest<void>(
-      "app.bsky.actor.profile.deleteRecord",
-      "POST",
-      { rkey }
-    );
+    return await this.client.deleteRecord("app.bsky.actor.profile", rkey);
   }
 }
 
-class ActorBskyAppClient extends BaseClient {
+class ActorBskyAppClient {
   readonly profile: ProfileActorBskyAppClient;
-  private readonly sliceUri: string;
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.profile = new ProfileActorBskyAppClient(
-      baseUrl,
-      sliceUri,
-      oauthClient
-    );
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.profile = new ProfileActorBskyAppClient(client);
   }
 }
 
-class BskyAppClient extends BaseClient {
+class BskyAppClient {
   readonly actor: ActorBskyAppClient;
-  private readonly sliceUri: string;
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.actor = new ActorBskyAppClient(baseUrl, sliceUri, oauthClient);
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.actor = new ActorBskyAppClient(client);
   }
 }
 
-class AppClient extends BaseClient {
+class AppClient {
   readonly bsky: BskyAppClient;
-  private readonly sliceUri: string;
+  private readonly client: SlicesClient;
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.bsky = new BskyAppClient(baseUrl, sliceUri, oauthClient);
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.bsky = new BskyAppClient(client);
   }
 }
 
-export class AtProtoClient extends BaseClient {
+export class AtProtoClient extends SlicesClient {
   readonly sh: ShClient;
   readonly app: AppClient;
   readonly oauth?: OAuthClient;
-  private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.sh = new ShClient(baseUrl, sliceUri, oauthClient);
-    this.app = new AppClient(baseUrl, sliceUri, oauthClient);
+    super(baseUrl, sliceUri, oauthClient);
+    this.sh = new ShClient(this);
+    this.app = new AppClient(this);
     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",
-      "POST",
-      requestParams
-    );
-  }
-
-  async getSliceRecords<T = Record<string, unknown>>(
-    params: Omit<SliceLevelRecordsParams<T>, "slice">
-  ): Promise<SliceRecordsOutput<T>> {
-    // Combine where and orWhere into the expected backend format
-    const whereClause: any = params?.where ? { ...params.where } : {};
-    if (params?.orWhere) {
-      whereClause.$or = params.orWhere;
-    }
-
-    const requestParams = {
-      ...params,
-      where: Object.keys(whereClause).length > 0 ? whereClause : undefined,
-      orWhere: undefined, // Remove orWhere as it's now in where.$or
-      slice: this.sliceUri,
-    };
-    return await this.makeRequest<SliceRecordsOutput<T>>(
-      "social.slices.slice.getSliceRecords",
-      "POST",
-      requestParams
-    );
-  }
-
-  uploadBlob(request: UploadBlobRequest): Promise<UploadBlobResponse> {
-    return this.uploadBlobWithRetry(request, false);
-  }
-
-  private async uploadBlobWithRetry(
-    request: UploadBlobRequest,
-    isRetry?: boolean
-  ): Promise<UploadBlobResponse> {
-    isRetry = isRetry ?? false;
-    // Special handling for blob upload with binary data
-    const httpMethod = "POST";
-    const url = `${this.baseUrl}/xrpc/com.atproto.repo.uploadBlob`;
-
-    if (!this.oauthClient) {
-      throw new Error("OAuth client not configured");
-    }
-
-    const tokens = await this.oauthClient.ensureValidToken();
-
-    const requestInit: RequestInit = {
-      method: httpMethod,
-      headers: {
-        "Content-Type": request.mimeType,
-        Authorization: `${tokens.tokenType} ${tokens.accessToken}`,
-      },
-      body: request.data,
-    };
-
-    const response = await fetch(url, requestInit);
-    if (!response.ok) {
-      // Handle 401 Unauthorized - attempt token refresh and retry once
-      if (response.status === 401 && !isRetry && this.oauthClient) {
-        try {
-          // Force token refresh by calling ensureValidToken again
-          await this.oauthClient.ensureValidToken();
-          // Retry the request once with refreshed tokens
-          return this.uploadBlobWithRetry(request, true);
-        } catch (_refreshError) {
-          throw new Error(
-            `Authentication required: OAuth tokens are invalid or expired. Please log in again.`
-          );
-        }
-      }
-
-      throw new Error(
-        `Blob upload failed: ${response.status} ${response.statusText}`
-      );
-    }
-
-    return await response.json();
-  }
-}
-
-// Utility function to convert BlobRef to CDN URL using record context
-export function recordBlobToCdnUrl<T>(
-  record: RecordResponse<T>,
-  blobRef: BlobRef,
-  preset?: "avatar" | "banner" | "feed_thumbnail" | "feed_fullsize",
-  cdnBaseUrl?: string
-): string {
-  const cdnBase = cdnBaseUrl || "https://cdn.bsky.app/img";
-  const sizePreset = preset || "feed_fullsize";
-  const cid = blobRef.ref.$link;
-  return `${cdnBase}/${sizePreset}/plain/${record.did}/${cid}@jpeg`;
 }

src/main.tsx

···
 import { renderToString } from "preact-render-to-string";
 import { fromJsx } from "@takumi-rs/helpers/jsx";
 import { Renderer } from "@takumi-rs/core";
+import { AtProtoClient, type AppBskyActorProfile } from "./generated_client.ts";
+import SharePage from "./components/SharePage.tsx";
+import SearchPage from "./components/SearchPage.tsx";
+import SearchResults from "./components/SearchResults.tsx";
+import RepoCard from "./components/RepoCard.tsx";
 import {
-  AtProtoClient,
-  type AppBskyActorProfile,
   type Actor,
   type IndexedRecord,
   type WhereCondition,
   recordBlobToCdnUrl,
-} from "./generated_client.ts";
-import SharePage from "./components/SharePage.tsx";
-import SearchPage from "./components/SearchPage.tsx";
-import SearchResults from "./components/SearchResults.tsx";
-import RepoCard from "./components/RepoCard.tsx";
+} from "@slices/client";
 
 const client = new AtProtoClient(
-  "https://slices-api.fly.dev",
-  "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lx6lhk7ibk2q"
+  "https://api.slices.network",
+  "at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhhbxald2z"
 );
 
 Deno.serve(async (req) => {