type cleanup

LEXICON_INTEGRATION.md

···
 ```astro
 ---
 import ContentDisplay from '../../components/content/ContentDisplay.astro';
-import type { AtprotoRecord } from '../../lib/types/atproto';
+import type { AtprotoRecord } from '../../lib/atproto/atproto-browser';
 
 const records: AtprotoRecord[] = await fetchRecords();
 ---

src/components/content/BlueskyFeed.astro

···
     blueskyPosts.map((record) => (
       <BlueskyPost 
         post={record.value} 
+        author={record.author}
         showAuthor={showAuthor}
         showTimestamp={showTimestamp}
       />

src/components/content/BlueskyPost.astro

···
 ---
-import type { BlueskyPost } from '../../lib/types/atproto';
+import type { AppBskyFeedPost } from '@atproto/api';
 import { extractCidFromBlobRef, blobCdnUrl } from '../../lib/atproto/blob-url';
 import { loadConfig } from '../../lib/config/site';
 
 interface Props {
-  post: BlueskyPost;
+  post: AppBskyFeedPost.Record;
+  author?: {
+    displayName?: string;
+    handle?: string;
+  };
   showAuthor?: boolean;
   showTimestamp?: boolean;
 }
 
-const { post, showAuthor = false, showTimestamp = true } = Astro.props;
+const { post, author, showAuthor = false, showTimestamp = true } = Astro.props;
 
 // Validate post data
 if (!post || !post.text) {
···
 ---
 
 <article class="bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700 p-4 mb-4">
-  {showAuthor && post.author && (
+  {showAuthor && author && (
     <div class="flex items-center mb-3">
       <div class="w-8 h-8 bg-blue-500 rounded-full flex items-center justify-center text-white text-sm font-medium">
-        {post.author.displayName?.[0] || 'U'}
+        {author.displayName?.[0] || 'U'}
       </div>
       <div class="ml-3">
         <div class="text-sm font-medium text-gray-900 dark:text-white">
-          {post.author.displayName || 'Unknown'}
+          {author.displayName || 'Unknown'}
         </div>
         <div class="text-xs text-gray-500 dark:text-gray-400">
-          @{post.author.handle || 'unknown'}
+          @{author.handle || 'unknown'}
         </div>
       </div>
     </div>
···
   {post.embed && (
     <div class="mb-3">
       {/* Handle image embeds */}
-      {post.embed.$type === 'app.bsky.embed.images' && post.embed.images && (
+      {post.embed.$type === 'app.bsky.embed.images' && 'images' in post.embed && post.embed.images && (
         renderImages(post.embed.images)
       )}
       
       {/* Handle external link embeds */}
-      {post.embed.$type === 'app.bsky.embed.external' && post.embed.external && (
+      {post.embed.$type === 'app.bsky.embed.external' && 'external' in post.embed && post.embed.external && (
         <div class="border border-gray-200 dark:border-gray-700 rounded-lg p-3">
           <div class="text-sm text-gray-600 dark:text-gray-400 mb-1">
             {post.embed.external.uri}
···
       )}
       
       {/* Handle record embeds (quotes/reposts) */}
-      {post.embed.$type === 'app.bsky.embed.record' && post.embed.record && (
+      {post.embed.$type === 'app.bsky.embed.record' && 'record' in post.embed && post.embed.record && (
         <div class="border border-gray-200 dark:border-gray-700 rounded-lg p-3 bg-gray-50 dark:bg-gray-700">
           <div class="text-sm text-gray-600 dark:text-gray-400">
             Quoted post

src/components/content/ContentDisplay.astro

···
 ---
-import type { AtprotoRecord } from '../../lib/types/atproto';
+import type { AtprotoRecord } from '../../lib/atproto/atproto-browser';
 import type { GeneratedLexiconUnion } from '../../lib/generated/lexicon-types';
 import { getComponentInfo, autoAssignComponent } from '../../lib/components/registry';
 import { loadConfig } from '../../lib/config/site';

src/components/content/ContentFeed.astro

···
 ---
 import { AtprotoBrowser } from '../../lib/atproto/atproto-browser';
 import { loadConfig } from '../../lib/config/site';
-import type { AtprotoRecord } from '../../lib/types/atproto';
+import type { AtprotoRecord } from '../../lib/atproto/atproto-browser';
 import { extractCidFromBlobRef, blobCdnUrl } from '../../lib/atproto/blob-url';
 
 

src/components/content/GrainImageGallery.astro

···
----
-import type { GrainImageGallery } from '../../lib/types/atproto';
-import type { SocialGrainGallery } from '../../lib/generated/social-grain-gallery';
-
-interface Props {
-  gallery: GrainImageGallery;
-  showDescription?: boolean;
-  showTimestamp?: boolean;
-  columns?: number;
-}
-
-const { gallery, showDescription = true, showTimestamp = true, columns = 3 } = Astro.props;
-
-const formatDate = (dateString: string) => {
-  return new Date(dateString).toLocaleDateString('en-US', {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-  });
-};
-
-const gridCols = {
-  1: 'grid-cols-1',
-  2: 'grid-cols-2',
-  3: 'grid-cols-3',
-  4: 'grid-cols-4',
-  5: 'grid-cols-5',
-  6: 'grid-cols-6',
-}[columns] || 'grid-cols-3';
----
-
-<article class="bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700 p-6 mb-6">
-  <header class="mb-4">
-    <h2 class="text-2xl font-bold text-gray-900 dark:text-white mb-2">
-      {gallery.title}
-    </h2>
-    
-    {showDescription && gallery.description && (
-      <div class="text-gray-600 dark:text-gray-400 mb-3">
-        {gallery.description}
-      </div>
-    )}
-    
-    {showTimestamp && (
-      <div class="text-sm text-gray-500 dark:text-gray-400 mb-4">
-        Created on {formatDate(gallery.createdAt)}
-      </div>
-    )}
-  </header>
-  
-  {gallery.images && gallery.images.length > 0 && (
-    <div class={`grid ${gridCols} gap-4`}>
-      {gallery.images.map((image) => (
-        <div class="relative group">
-          <img 
-            src={image.url} 
-            alt={image.alt || 'Gallery image'} 
-            class="w-full h-48 object-cover rounded-lg transition-transform duration-200 group-hover:scale-105"
-          />
-          {image.alt && (
-            <div class="absolute bottom-0 left-0 right-0 bg-black bg-opacity-50 text-white text-sm p-2 rounded-b-lg opacity-0 group-hover:opacity-100 transition-opacity duration-200">
-              {image.alt}
-            </div>
-          )}
-        </div>
-      ))}
-    </div>
-  )}
-</article> 

src/components/content/LeafletPublication.astro

···
----
-import type { LeafletPublication } from '../../lib/types/atproto';
-
-interface Props {
-  publication: LeafletPublication;
-  showCategory?: boolean;
-  showTimestamp?: boolean;
-}
-
-const { publication, showCategory = true, showTimestamp = true } = Astro.props;
-
-const formatDate = (dateString: string) => {
-  return new Date(dateString).toLocaleDateString('en-US', {
-    year: 'numeric',
-    month: 'long',
-    day: 'numeric',
-  });
-};
----
-
-<article class="bg-white dark:bg-gray-800 rounded-lg shadow-sm border border-gray-200 dark:border-gray-700 p-6 mb-6">
-  <header class="mb-4">
-    <div class="flex items-center justify-between mb-2">
-      <h2 class="text-2xl font-bold text-gray-900 dark:text-white">
-        {publication.title}
-      </h2>
-      
-      {showCategory && publication.category && (
-        <span class="px-3 py-1 bg-green-100 dark:bg-green-900 text-green-800 dark:text-green-200 text-sm rounded-full">
-          {publication.category}
-        </span>
-      )}
-    </div>
-    
-    {showTimestamp && (
-      <div class="text-sm text-gray-500 dark:text-gray-400 mb-3">
-        Published on {formatDate(publication.publishedAt)}
-      </div>
-    )}
-  </header>
-  
-  <div class="prose prose-gray dark:prose-invert max-w-none">
-    <div class="text-gray-700 dark:text-gray-300 leading-relaxed">
-      {publication.content}
-    </div>
-  </div>
-</article> 

src/lib/atproto/atproto-browser.ts

···
   indexedAt: string;
   collection: string;
   $type: string;
+  author?: {
+    displayName?: string;
+    handle?: string;
+  };
 }
 
 export interface RepoInfo {
···
         indexedAt: item.post.indexedAt,
         collection: item.post.uri.split('/')[2] || 'unknown',
         $type: (item.post.record?.$type as string) || 'unknown',
+        author: item.post.author ? {
+          displayName: item.post.author.displayName,
+          handle: item.post.author.handle,
+        } : undefined,
       }));
 
       return records;

src/lib/components/register.ts

···
-import { registerComponent } from './registry';
-import BlueskyPost from '../../components/content/BlueskyPost.astro';
-import WhitewindBlogPost from '../../components/content/WhitewindBlogPost.astro';
-import LeafletPublication from '../../components/content/LeafletPublication.astro';
-import GrainImageGallery from '../../components/content/GrainImageGallery.astro';
-
-// Register all content components
-export function registerAllComponents() {
-  // Register Bluesky post component
-  registerComponent('app.bsky.feed.post', BlueskyPost);
-  
-  // Register Whitewind blog post component
-  registerComponent('app.bsky.actor.profile#whitewindBlogPost', WhitewindBlogPost);
-  
-  // Register Leaflet publication component
-  registerComponent('app.bsky.actor.profile#leafletPublication', LeafletPublication);
-  
-  // Register Grain image gallery component
-  registerComponent('app.bsky.actor.profile#grainImageGallery', GrainImageGallery);
-}
-
-// Auto-register components when this module is imported
-registerAllComponents(); 

src/lib/components/registry.ts

···
     component: 'StatusUpdate',
     props: {}
   },
-  // Add more mappings as you create components
-  // 'ComExampleRecord': {
-  //   component: 'ExampleComponent',
-  //   props: {}
-  // }
+  // Bluesky posts (not in generated types, but used by components)
+  'app.bsky.feed.post': {
+    component: 'BlueskyPost',
+    props: {}
+  },
+
 };
 
 // Type-safe component lookup

src/lib/services/content-renderer.ts

···
 import { AtprotoBrowser } from '../atproto/atproto-browser';
 import { loadConfig } from '../config/site';
-import type { AtprotoRecord } from '../types/atproto';
+import type { AtprotoRecord } from '../atproto/atproto-browser';
 
 export interface ContentRendererOptions {
   showAuthor?: boolean;
···
       'app.bsky.feed.post': 'BlueskyPost',
       'app.bsky.actor.profile#whitewindBlogPost': 'WhitewindBlogPost',
       'app.bsky.actor.profile#leafletPublication': 'LeafletPublication',
-      'app.bsky.actor.profile#grainImageGallery': 'GrainImageGallery',
+
       'gallery.display': 'GalleryDisplay',
     };
 

src/lib/services/content-system.ts

···
 import { JetstreamClient } from '../atproto/jetstream-client';
 import { GrainGalleryService } from './grain-gallery-service';
 import { loadConfig } from '../config/site';
-import type { AtprotoRecord } from '../types/atproto';
+import type { AtprotoRecord } from '../atproto/atproto-browser';
 
 export interface ContentItem {
   uri: string;

src/lib/types/atproto.ts

···
-// Base ATproto record types
-import type { AtprotoRecord } from '../atproto/atproto-browser';
-export type { AtprotoRecord };
-
-// Bluesky post types with proper embed handling
-export interface BlueskyPost {
-  text: string;
-  createdAt: string;
-  embed?: {
-    $type: 'app.bsky.embed.images' | 'app.bsky.embed.external' | 'app.bsky.embed.record';
-    images?: Array<{
-      alt?: string;
-      image: {
-        $type: 'blob';
-        ref: {
-          $link: string;
-        };
-        mimeType: string;
-        size: number;
-      };
-      aspectRatio?: {
-        width: number;
-        height: number;
-      };
-    }>;
-    external?: {
-      uri: string;
-      title: string;
-      description?: string;
-    };
-    record?: {
-      uri: string;
-      cid: string;
-    };
-  };
-  author?: {
-    displayName?: string;
-    handle?: string;
-  };
-  reply?: {
-    root: {
-      uri: string;
-      cid: string;
-    };
-    parent: {
-      uri: string;
-      cid: string;
-    };
-  };
-  facets?: Array<{
-    index: {
-      byteStart: number;
-      byteEnd: number;
-    };
-    features: Array<{
-      $type: string;
-      [key: string]: any;
-    }>;
-  }>;
-  langs?: string[];
-  uri?: string;
-  cid?: string;
-}
-
-// Custom lexicon types (to be extended)
-export interface CustomLexiconRecord {
-  $type: string;
-  [key: string]: any;
-}
-
-// Whitewind blog post type
-export interface WhitewindBlogPost extends CustomLexiconRecord {
-  $type: 'app.bsky.actor.profile#whitewindBlogPost';
-  title: string;
-  content: string;
-  publishedAt: string;
-  tags?: string[];
-}
-
-// Leaflet publication type
-export interface LeafletPublication extends CustomLexiconRecord {
-  $type: 'app.bsky.actor.profile#leafletPublication';
-  title: string;
-  content: string;
-  publishedAt: string;
-  category?: string;
-}
-
-// Grain social image gallery type
-export interface GrainImageGallery extends CustomLexiconRecord {
-  $type: 'app.bsky.actor.profile#grainImageGallery';
-  title: string;
-  description?: string;
-  images: Array<{
-    alt: string;
-    url: string;
-  }>;
-  createdAt: string;
-}
-
-// Generic grain gallery post type (for posts that contain galleries)
-export interface GrainGalleryPost extends CustomLexiconRecord {
-  $type: 'app.bsky.feed.post#grainGallery' | 'app.bsky.feed.post#grainImageGallery';
-  text?: string;
-  createdAt: string;
-  embed?: {
-    $type: 'app.bsky.embed.images';
-    images?: Array<{
-      alt?: string;
-      image: {
-        $type: 'blob';
-        ref: string;
-        mimeType: string;
-        size: number;
-      };
-      aspectRatio?: {
-        width: number;
-        height: number;
-      };
-    }>;
-  };
-}
-
-// Union type for all supported content types
-export type SupportedContentType = 
-  | BlueskyPost 
-  | WhitewindBlogPost 
-  | LeafletPublication 
-  | GrainImageGallery
-  | GrainGalleryPost;
-
-// Component registry type
-export interface ContentComponent {
-  type: string;
-  component: any;
-  props?: Record<string, any>;
-}
-
-// Feed configuration type
-export interface FeedConfig {
-  uri: string;
-  limit?: number;
-  filter?: (record: AtprotoRecord) => boolean;
-} 

src/lib/types/generator.ts

···
-import type { DiscoveredLexicon } from '../atproto/discovery';
-
-export interface GeneratedType {
-  name: string;
-  interface: string;
-  $type: string;
-  properties: Record<string, any>;
-  service: string;
-  collection: string;
-}
-
-export class TypeGenerator {
-  private generatedTypes: Map<string, GeneratedType> = new Map();
-
-  // Generate TypeScript interface from a discovered lexicon
-  generateTypeFromLexicon(lexicon: DiscoveredLexicon): GeneratedType {
-    const $type = lexicon.$type;
-    
-    // Skip if already generated
-    if (this.generatedTypes.has($type)) {
-      return this.generatedTypes.get($type)!;
-    }
-
-    const typeName = this.generateTypeName($type);
-    const interfaceCode = this.generateInterfaceCode(typeName, lexicon);
-
-    const generatedType: GeneratedType = {
-      name: typeName,
-      interface: interfaceCode,
-      $type,
-      properties: lexicon.properties,
-      service: lexicon.service,
-      collection: lexicon.collection
-    };
-
-    this.generatedTypes.set($type, generatedType);
-    return generatedType;
-  }
-
-  // Generate type name from $type
-  private generateTypeName($type: string): string {
-    const parts = $type.split('#');
-    if (parts.length > 1) {
-      return parts[1].charAt(0).toUpperCase() + parts[1].slice(1);
-    }
-    
-    const lastPart = $type.split('.').pop() || 'Unknown';
-    return lastPart.charAt(0).toUpperCase() + lastPart.slice(1);
-  }
-
-  // Generate TypeScript interface code
-  private generateInterfaceCode(name: string, lexicon: DiscoveredLexicon): string {
-    const propertyLines = Object.entries(lexicon.properties).map(([key, type]) => {
-      return `  ${key}: ${type};`;
-    });
-
-    return `export interface ${name} extends CustomLexiconRecord {
-  $type: '${lexicon.$type}';
-${propertyLines.join('\n')}
-}`;
-  }
-
-  // Generate all types from discovered lexicons
-  generateTypesFromLexicons(lexicons: DiscoveredLexicon[]): GeneratedType[] {
-    const types: GeneratedType[] = [];
-    
-    lexicons.forEach(lexicon => {
-      const type = this.generateTypeFromLexicon(lexicon);
-      types.push(type);
-    });
-    
-    return types;
-  }
-
-  // Get all generated types
-  getAllGeneratedTypes(): GeneratedType[] {
-    return Array.from(this.generatedTypes.values());
-  }
-
-  // Generate complete types file content
-  generateTypesFile(lexicons: DiscoveredLexicon[]): string {
-    const types = this.generateTypesFromLexicons(lexicons);
-    
-    if (types.length === 0) {
-      return '// No types generated';
-    }
-
-    const imports = `import type { CustomLexiconRecord } from './atproto';`;
-    const interfaces = types.map(type => type.interface).join('\n\n');
-    const unionType = this.generateUnionType(types);
-    const serviceGroups = this.generateServiceGroups(types);
-
-    return `${imports}
-
-${interfaces}
-
-${unionType}
-
-${serviceGroups}`;
-  }
-
-  // Generate union type for all generated types
-  private generateUnionType(types: GeneratedType[]): string {
-    const typeNames = types.map(t => t.name);
-    return `// Union type for all generated content types
-export type GeneratedContentType = ${typeNames.join(' | ')};`;
-  }
-
-  // Generate service-specific type groups
-  private generateServiceGroups(types: GeneratedType[]): string {
-    const serviceGroups = new Map<string, GeneratedType[]>();
-    
-    types.forEach(type => {
-      if (!serviceGroups.has(type.service)) {
-        serviceGroups.set(type.service, []);
-      }
-      serviceGroups.get(type.service)!.push(type);
-    });
-
-    let serviceGroupsCode = '';
-    serviceGroups.forEach((types, service) => {
-      const typeNames = types.map(t => t.name);
-      serviceGroupsCode += `
-// ${service} types
-export type ${this.capitalizeService(service)}ContentType = ${typeNames.join(' | ')};`;
-    });
-
-    return serviceGroupsCode;
-  }
-
-  // Capitalize service name for type name
-  private capitalizeService(service: string): string {
-    return service.split('.').map(part => 
-      part.charAt(0).toUpperCase() + part.slice(1)
-    ).join('');
-  }
-
-  // Clear all generated types
-  clear(): void {
-    this.generatedTypes.clear();
-  }
-}
-
-// Global type generator instance
-export const typeGenerator = new TypeGenerator();